modelmix 4.5.1 → 4.5.2

package/http-client.js

@@ -0,0 +1,80 @@
+const { Readable } = require('stream');
+
+function headersToObject(headers) {
+    return Object.fromEntries(headers.entries());
+}
+
+async function parseResponseBody(response) {
+    try {
+        return await response.json();
+    } catch {
+        try {
+            return await response.text();
+        } catch {
+            return null;
+        }
+    }
+}
+
+async function parseJsonBody(response) {
+    const text = await response.text();
+    if (!text) return null;
+    return JSON.parse(text);
+}
+
+async function buildHttpError(url, response) {
+    const details = await parseResponseBody(response);
+    const error = new Error(`Request to ${url} failed with status code ${response.status}`);
+    error.isHttpError = true;
+    error.statusCode = response.status;
+    error.details = details;
+    error.response = { status: response.status, data: details };
+    return error;
+}
+
+async function fetchJsonResponse(url, { method = 'POST', headers = {}, body } = {}) {
+    const response = await fetch(url, { method, headers, body });
+    if (!response.ok) {
+        throw await buildHttpError(url, response);
+    }
+    const data = await parseJsonBody(response);
+    return {
+        data,
+        status: response.status,
+        headers: headersToObject(response.headers)
+    };
+}
+
+async function fetchBinaryResponse(url, { method = 'GET', headers = {}, body } = {}) {
+    const response = await fetch(url, { method, headers, body });
+    if (!response.ok) {
+        throw await buildHttpError(url, response);
+    }
+    const data = Buffer.from(await response.arrayBuffer());
+    return {
+        data,
+        status: response.status,
+        headers: headersToObject(response.headers)
+    };
+}
+
+async function fetchStreamResponse(url, { method = 'POST', headers = {}, body } = {}) {
+    const response = await fetch(url, { method, headers, body });
+    if (!response.ok) {
+        throw await buildHttpError(url, response);
+    }
+    if (!response.body) {
+        throw new Error(`Request to ${url} did not return a readable stream`);
+    }
+    return {
+        data: Readable.fromWeb(response.body),
+        status: response.status,
+        headers: headersToObject(response.headers)
+    };
+}
+
+module.exports = {
+    fetchJsonResponse,
+    fetchBinaryResponse,
+    fetchStreamResponse
+};

package/index.js

@@ -2,7 +2,6 @@ const fs = require('fs');
 const fileType = require('file-type');
 const detectFileTypeFromBuffer = fileType.fileTypeFromBuffer || fileType.fromBuffer;
 const { inspect } = require('util');
-const { Readable } = require('stream');
 const log = require('lemonlog')('ModelMix');
 const Bottleneck = require('bottleneck');
 const path = require('path');
@@ -11,79 +10,16 @@ const generateJsonSchema = require('./schema');
 const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
 const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
 const { MCPToolsManager } = require('./mcp-tools');
-
-function headersToObject(headers) {
-    return Object.fromEntries(headers.entries());
-}
-
-async function parseResponseBody(response) {
-    try {
-        return await response.json();
-    } catch {
-        try {
-            return await response.text();
-        } catch {
-            return null;
-        }
-    }
-}
-
-async function parseJsonBody(response) {
-    const text = await response.text();
-    if (!text) return null;
-    return JSON.parse(text);
-}
-
-async function buildHttpError(url, response) {
-    const details = await parseResponseBody(response);
-    const error = new Error(`Request to ${url} failed with status code ${response.status}`);
-    error.isHttpError = true;
-    error.statusCode = response.status;
-    error.details = details;
-    error.response = { status: response.status, data: details };
-    return error;
-}
-
-async function fetchJsonResponse(url, { method = 'POST', headers = {}, body } = {}) {
-    const response = await fetch(url, { method, headers, body });
-    if (!response.ok) {
-        throw await buildHttpError(url, response);
-    }
-    const data = await parseJsonBody(response);
-    return {
-        data,
-        status: response.status,
-        headers: headersToObject(response.headers)
-    };
-}
-
-async function fetchBinaryResponse(url, { method = 'GET', headers = {}, body } = {}) {
-    const response = await fetch(url, { method, headers, body });
-    if (!response.ok) {
-        throw await buildHttpError(url, response);
-    }
-    const data = Buffer.from(await response.arrayBuffer());
-    return {
-        data,
-        status: response.status,
-        headers: headersToObject(response.headers)
-    };
-}
-
-async function fetchStreamResponse(url, { method = 'POST', headers = {}, body } = {}) {
-    const response = await fetch(url, { method, headers, body });
-    if (!response.ok) {
-        throw await buildHttpError(url, response);
-    }
-    if (!response.body) {
-        throw new Error(`Request to ${url} did not return a readable stream`);
-    }
-    return {
-        data: Readable.fromWeb(response.body),
-        status: response.status,
-        headers: headersToObject(response.headers)
-    };
-}
+const {
+    stripContentTypeHeader,
+    createMultipartFormData,
+    buildRequestBodyAndHeaders
+} = require('./multipart');
+const {
+    fetchJsonResponse,
+    fetchBinaryResponse,
+    fetchStreamResponse
+} = require('./http-client');
 
 const DEFAULT_RETRYABLE_STATUS_CODES = [408, 425, 429, 500, 502, 503, 504, 529];
 
@@ -1389,10 +1325,25 @@ class MixCustom {
         return MixOpenAI.convertMessages(messages, config);
     }
 
+    static stripContentTypeHeader(headers = {}) {
+        return stripContentTypeHeader(headers);
+    }
+
+    static createMultipartFormData({ fields = {}, files = [] } = {}) {
+        return createMultipartFormData({ fields, files });
+    }
+
+    static buildRequestBodyAndHeaders(options, headers) {
+        return buildRequestBodyAndHeaders(options, headers);
+    }
+
     async create({ config = {}, options = {} } = {}) {
         try {
+            if (Array.isArray(options.messages)) {
+                options.messages = this.convertMessages(options.messages, config);
+            }
 
-            options.messages = this.convertMessages(options.messages, config);
+            const request = buildRequestBodyAndHeaders(options, this.headers);
 
             // debug level 4 (verbose): Full request details
             if (config.debug >= 4) {
@@ -1404,20 +1355,20 @@ class MixCustom {
                 console.log(ModelMix.formatJSON(configToLog));
 
                 console.log('\n[OPTIONS]');
-                console.log(ModelMix.formatJSON(options));
+                console.log(ModelMix.formatJSON(request.options));
             }
 
             if (options.stream) {
                 return this.processStream(await fetchStreamResponse(this.config.url, {
                     method: 'POST',
-                    headers: this.headers,
-                    body: JSON.stringify(options)
+                    headers: request.headers,
+                    body: request.body
                 }));
             } else {
                 return this.processResponse(await fetchJsonResponse(this.config.url, {
                     method: 'POST',
-                    headers: this.headers,
-                    body: JSON.stringify(options)
+                    headers: request.headers,
+                    body: request.body
                 }));
             }
         } catch (error) {
@@ -2236,6 +2187,7 @@ class MixAnthropic extends MixCustom {
 
     static extractMessage(data) {
         const content = Array.isArray(data?.content) ? data.content : [];
+        const stopReason = data?.stop_reason;
 
         // Anthropic can return text in different positions depending on thinking/tool blocks.
         const textBlock = content.find(block => typeof block?.text === 'string' && block.text.trim().length > 0);
@@ -2243,8 +2195,12 @@ class MixAnthropic extends MixCustom {
             return textBlock.text;
         }
 
+        // A tool_use turn can legitimately contain no text blocks.
+        if (stopReason === 'tool_use') {
+            return '';
+        }
+
         // Empty/non-text content is often due to safety refusal or token limits.
-        const stopReason = data?.stop_reason;
         const contentTypes = content.map(block => block?.type || 'unknown').join(', ') || 'none';
 
         if (stopReason === 'refusal') {

package/multipart.js

@@ -0,0 +1,111 @@
+const fs = require('fs');
+const path = require('path');
+
+function stripContentTypeHeader(headers = {}) {
+    const sanitizedHeaders = {};
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() !== 'content-type') {
+            sanitizedHeaders[name] = value;
+        }
+    }
+    return sanitizedHeaders;
+}
+
+function createMultipartFormData({ fields = {}, files = [] } = {}) {
+    if (typeof FormData !== 'function' || typeof Blob !== 'function') {
+        throw new Error('Native FormData/Blob are not available in this Node.js runtime');
+    }
+
+    const formData = new FormData();
+
+    for (const [name, value] of Object.entries(fields)) {
+        if (value === undefined || value === null) continue;
+        const normalizedValue = typeof value === 'string' ? value : JSON.stringify(value);
+        formData.append(name, normalizedValue);
+    }
+
+    for (const file of files) {
+        if (!file || !file.name) {
+            throw new Error('Each multipart file must include a "name" property');
+        }
+
+        let data = file.data;
+        let filename = file.filename;
+
+        if (file.path) {
+            const absolutePath = path.resolve(file.path);
+            data = fs.readFileSync(absolutePath);
+            filename = filename || path.basename(absolutePath);
+        }
+
+        if (typeof data === 'string') {
+            data = Buffer.from(data);
+        } else if (data instanceof ArrayBuffer) {
+            data = Buffer.from(data);
+        } else if (ArrayBuffer.isView(data)) {
+            data = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        }
+
+        if (!Buffer.isBuffer(data)) {
+            throw new Error(`Invalid multipart file data for "${file.name}" - expected Buffer, ArrayBuffer, typed array, string, or file path`);
+        }
+
+        const blob = new Blob([data], {
+            type: file.contentType || 'application/octet-stream'
+        });
+
+        formData.append(file.name, blob, filename || 'file');
+    }
+
+    return formData;
+}
+
+function buildRequestBodyAndHeaders(options, headers) {
+    if (options?.body instanceof FormData) {
+        const requestOptions = { ...options };
+        delete requestOptions.body;
+        return {
+            options: requestOptions,
+            body: options.body,
+            headers: stripContentTypeHeader(headers)
+        };
+    }
+
+    if (options?.multipart) {
+        const requestOptions = { ...options };
+        const multipartConfig = requestOptions.multipart || {};
+        delete requestOptions.multipart;
+
+        const serializedFields = {};
+        for (const [key, value] of Object.entries(requestOptions)) {
+            if (value === undefined) continue;
+            serializedFields[key] = value;
+        }
+
+        const body = createMultipartFormData({
+            fields: {
+                ...serializedFields,
+                ...(multipartConfig.fields || {})
+            },
+            files: multipartConfig.files || []
+        });
+
+        return {
+            options: requestOptions,
+            body,
+            headers: stripContentTypeHeader(headers)
+        };
+    }
+
+    return {
+        options,
+        body: JSON.stringify(options),
+        headers
+    };
+}
+
+module.exports = {
+    stripContentTypeHeader,
+    createMultipartFormData,
+    buildRequestBodyAndHeaders
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.5.1",
+  "version": "4.5.2",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "repository": {
@@ -50,7 +50,6 @@
     "@modelcontextprotocol/sdk": "^1.27.1",
     "bottleneck": "^2.19.5",
     "file-type": "^21.3.3",
-    "form-data": "^4.0.4",
     "lemonlog": "^1.2.0",
     "ws": "^8.19.0"
   },

package/test/live.mcp.js

@@ -60,8 +60,8 @@ describe('Live MCP Integration Tests', function () {
 
     describe('Basic MCP Tool Integration', function () {
 
-        it('should use custom MCP tools with GPT-5.2', async function () {
-            const model = ModelMix.new(setup).gpt52();
+        it('should use custom MCP tools with GPT-5.4', async function () {
+            const model = ModelMix.new(setup).gpt54();
 
             // Add custom calculator tool
             model.addTool({

package/test/live.test.js

@@ -299,8 +299,8 @@ describe('Live Integration Tests', function () {
             expect(result.abilities).to.be.an('array');
         });
 
-        it('should return structured JSON with KimiK2', async function () {
-            const model = ModelMix.new(setup).kimiK2();
+        it('should return structured JSON with KimiK25 Thinking', async function () {
+            const model = ModelMix.new(setup).kimiK25think();
 
             model.addText('Generate information about a fictional vehicle.');
 
@@ -321,30 +321,8 @@ describe('Live Integration Tests', function () {
             expect(result.features).to.be.an('array');
         });
 
-        it('should return structured JSON with GPT-OSS', async function () {
-            const model = ModelMix.new(setup).gptOss();
-
-            model.addText('Generate information about a fictional planet.');
-
-            const result = await model.json({
-                name: "Nova Prime",
-                type: "Gas Giant",
-                moons: ["Alpha", "Beta", "Gamma"],
-                atmosphere: "Hydrogen and Helium"
-            });
-
-            console.log(`GPT-OSS JSON result:`, result);
-
-            expect(result).to.be.an('object');
-            expect(result).to.have.property('name');
-            expect(result).to.have.property('type');
-            expect(result).to.have.property('moons');
-            expect(result).to.have.property('atmosphere');
-            expect(result.moons).to.be.an('array');
-        });
-
         it('should return structured JSON with Grok3Mini', async function () {
-            const model = ModelMix.new(setup).grok3mini();
+            const model = ModelMix.new(setup).grok41();
 
             model.addText('Generate information about a fictional technology.');
 

package/test/multipart.test.js

@@ -0,0 +1,99 @@
+const { expect } = require('chai');
+const { MixCustom } = require('../index.js');
+
+describe('Native multipart support', () => {
+    let originalFetch;
+
+    beforeEach(() => {
+        originalFetch = global.fetch;
+    });
+
+    afterEach(() => {
+        global.fetch = originalFetch;
+    });
+
+    it('should create FormData from fields and files', () => {
+        const formData = MixCustom.createMultipartFormData({
+            fields: {
+                model: 'whisper-1',
+                metadata: { source: 'test' }
+            },
+            files: [{
+                name: 'file',
+                data: Buffer.from('hello'),
+                filename: 'hello.txt',
+                contentType: 'text/plain'
+            }]
+        });
+
+        expect(formData).to.be.instanceOf(FormData);
+        expect(formData.get('model')).to.equal('whisper-1');
+        expect(formData.get('metadata')).to.equal('{"source":"test"}');
+
+        const uploadedFile = formData.get('file');
+        expect(uploadedFile).to.exist;
+        expect(uploadedFile.name).to.equal('hello.txt');
+        expect(uploadedFile.type).to.equal('text/plain');
+    });
+
+    it('should remove content-type header for multipart requests', () => {
+        const request = MixCustom.buildRequestBodyAndHeaders({
+            multipart: {
+                fields: { model: 'whisper-1' }
+            }
+        }, {
+            accept: 'application/json',
+            'content-type': 'application/json',
+            authorization: 'Bearer test'
+        });
+
+        expect(request.body).to.be.instanceOf(FormData);
+        expect(request.headers).to.deep.equal({
+            accept: 'application/json',
+            authorization: 'Bearer test'
+        });
+    });
+
+    it('should send multipart body in create()', async () => {
+        let capturedRequest = null;
+
+        global.fetch = async (url, request) => {
+            capturedRequest = { url, request };
+            return new Response(JSON.stringify({
+                choices: [{
+                    message: { content: 'ok' }
+                }]
+            }), {
+                status: 200,
+                headers: { 'content-type': 'application/json' }
+            });
+        };
+
+        const mix = new MixCustom({
+            config: {
+                url: 'https://api.example.com/v1/upload',
+                apiKey: 'token'
+            }
+        });
+
+        const result = await mix.create({
+            options: {
+                stream: false,
+                multipart: {
+                    fields: { purpose: 'test' },
+                    files: [{
+                        name: 'file',
+                        data: Buffer.from('sample'),
+                        filename: 'sample.txt',
+                        contentType: 'text/plain'
+                    }]
+                }
+            }
+        });
+
+        expect(result.message).to.equal('ok');
+        expect(capturedRequest.url).to.equal('https://api.example.com/v1/upload');
+        expect(capturedRequest.request.body).to.be.instanceOf(FormData);
+        expect(capturedRequest.request.headers).to.not.have.property('content-type');
+    });
+});