modelmix 3.8.2 → 3.8.4

package/test/json.test.js

@@ -0,0 +1,295 @@
+const { expect } = require('chai');
+const sinon = require('sinon');
+const nock = require('nock');
+const { ModelMix } = require('../index.js');
+const generateJsonSchema = require('../schema.js');
+
+
+describe('JSON Schema and Structured Output Tests', () => {
+    
+    // Setup test hooks
+    if (global.setupTestHooks) {
+        global.setupTestHooks();
+    }
+    
+    afterEach(() => {
+        nock.cleanAll();
+        sinon.restore();
+    });
+
+    describe('JSON Schema Generation', () => {
+        it('should generate schema for simple object', () => {
+            const example = {
+                name: 'Alice',
+                age: 30,
+                isAdmin: false
+            };
+            
+            const schema = generateJsonSchema(example);
+            
+            expect(schema).to.deep.equal({
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    age: { type: 'integer' },
+                    isAdmin: { type: 'boolean' }
+                },
+                required: ['name', 'age', 'isAdmin']
+            });
+        });
+
+        it('should generate schema with email format detection', () => {
+            const example = { email: 'test@example.com' };
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.email).to.deep.equal({
+                type: 'string',
+                format: 'email'
+            });
+        });
+
+        it('should generate schema with date format detection', () => {
+            const example = { birthDate: '1990-01-01' };
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.birthDate).to.deep.equal({
+                type: 'string',
+                format: 'date',
+                description: 'Date in format YYYY-MM-DD'
+            });
+        });
+
+        it('should generate schema with time format detection', () => {
+            const example = { 
+                time1: '14:30',
+                time2: '09:15:45'
+            };
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.time1).to.deep.equal({
+                type: 'string',
+                format: 'time',
+                description: 'Time in format HH:MM'
+            });
+            
+            expect(schema.properties.time2).to.deep.equal({
+                type: 'string',
+                format: 'time',
+                description: 'Time in format HH:MM:SS'
+            });
+        });
+
+        it('should handle nested objects', () => {
+            const example = {
+                user: {
+                    name: 'Bob',
+                    preferences: {
+                        theme: 'dark'
+                    }
+                }
+            };
+            
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.user.type).to.equal('object');
+            expect(schema.properties.user.properties.name).to.deep.equal({ type: 'string' });
+            expect(schema.properties.user.properties.preferences.type).to.equal('object');
+        });
+
+        it('should handle arrays of objects', () => {
+            const example = {
+                users: [{
+                    name: 'Alice',
+                    age: 30
+                }]
+            };
+            
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.users).to.deep.equal({
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        age: { type: 'integer' }
+                    },
+                    required: ['name', 'age']
+                }
+            });
+        });
+
+        it('should handle arrays of primitives', () => {
+            const example = {
+                tags: ['admin', 'user'],
+                numbers: [1, 2, 3]
+            };
+            
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.tags).to.deep.equal({
+                type: 'array',
+                items: { type: 'string' }
+            });
+            
+            expect(schema.properties.numbers).to.deep.equal({
+                type: 'array',
+                items: { type: 'integer' }
+            });
+        });
+
+        it('should handle custom descriptions', () => {
+            const example = { name: 'Alice', age: 30 };
+            const descriptions = {
+                name: 'Full name of the user',
+                age: 'User age in years'
+            };
+            
+            const schema = generateJsonSchema(example, descriptions);
+            
+            expect(schema.properties.name.description).to.equal('Full name of the user');
+            expect(schema.properties.age.description).to.equal('User age in years');
+        });
+
+        it('should handle null values', () => {
+            const example = { data: null };
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.data).to.deep.equal({ type: 'null' });
+        });
+
+        it('should distinguish between integer and float', () => {
+            const example = {
+                count: 42,
+                price: 19.99
+            };
+            
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.count).to.deep.equal({ type: 'integer' });
+            expect(schema.properties.price).to.deep.equal({ type: 'number' });
+        });
+
+        it('should handle empty arrays', () => {
+            const example = { items: [] };
+            const schema = generateJsonSchema(example);
+            
+            expect(schema.properties.items).to.deep.equal({
+                type: 'array',
+                items: {}
+            });
+        });
+    });
+
+    describe('ModelMix JSON Output', () => {
+        let model;
+
+        beforeEach(() => {
+            model = ModelMix.new({
+                config: { debug: false }
+            });
+        });
+
+        it('should prepare JSON schema for structured output', async () => {
+            const example = {
+                countries: [{
+                    name: 'France',
+                    capital: 'Paris'
+                }]
+            };
+            
+            model.gpt4o().addText('List 3 countries');
+            
+            // Mock the API response
+            nock('https://api.openai.com')
+                .post('/v1/chat/completions')
+                .reply(200, {
+                    choices: [{
+                        message: {
+                            role: 'assistant',
+                            content: JSON.stringify({
+                                countries: [
+                                    { name: 'France', capital: 'Paris' },
+                                    { name: 'Germany', capital: 'Berlin' },
+                                    { name: 'Spain', capital: 'Madrid' }
+                                ]
+                            })
+                        }
+                    }]
+                });
+
+            const result = await model.json(example);
+            
+            expect(result).to.have.property('countries');
+            expect(result.countries).to.be.an('array');
+            expect(result.countries).to.have.length(3);
+            expect(result.countries[0]).to.have.property('name');
+            expect(result.countries[0]).to.have.property('capital');
+        });
+
+        it('should handle complex nested JSON schema', async () => {
+            const example = {
+                user: {
+                    personal: {
+                        name: 'John',
+                        age: 25
+                    },
+                    contact: {
+                        email: 'john@example.com',
+                        phone: '123-456-7890'
+                    },
+                    preferences: {
+                        notifications: true,
+                        theme: 'dark'
+                    }
+                },
+                metadata: {
+                    createdAt: '2023-01-01',
+                    tags: ['premium', 'verified']
+                }
+            };
+
+            model.sonnet4().addText('Generate user data');
+            
+            // Mock the API response
+            nock('https://api.anthropic.com')
+                .post('/v1/messages')
+                .reply(200, {
+                    content: [{
+                        type: 'text',
+                        text: JSON.stringify(example)
+                    }]
+                });
+
+            const result = await model.json(example);
+            
+            expect(result.user.personal.name).to.equal('John');
+            expect(result.user.contact.email).to.equal('john@example.com');
+            expect(result.metadata.tags).to.be.an('array');
+            expect(result.metadata.tags).to.deep.equal(['premium', 'verified']);
+        });
+
+        it('should handle JSON parsing errors gracefully', async () => {
+            model.gpt4o().addText('Generate invalid JSON');
+            
+            // Mock invalid JSON response
+            nock('https://api.openai.com')
+                .post('/v1/chat/completions')
+                .reply(200, {
+                    choices: [{
+                        message: {
+                            role: 'assistant',
+                            content: 'This is not valid JSON'
+                        }
+                    }]
+                });
+
+            try {
+                await model.json({ name: 'test' });
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error.message).to.include('JSON');
+            }
+        });
+    });
+});

package/test/live.test.js

@@ -0,0 +1,356 @@
+const { expect } = require('chai');
+const { ModelMix, MixOpenAI, MixAnthropic, MixGoogle } = require('../index.js');
+const path = require('path');
+const fixturesPath = path.join(__dirname, 'fixtures');
+
+const blueSquareBase64 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAMAAABHPGVmAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDkuMS1jMDAzIDc5Ljk2OTBhODdmYywgMjAyNS8wMy8wNi0yMDo1MDoxNiAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIDI2LjkgKE1hY2ludG9zaCkiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6REM2QzQ3NEQ2Q0I5MTFGMDlBRTVGQzcwQjMyMkY4MDciIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6REM2QzQ3NEU2Q0I5MTFGMDlBRTVGQzcwQjMyMkY4MDciPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDpEQzZDNDc0QjZDQjkxMUYwOUFFNUZDNzBCMzIyRjgwNyIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDpEQzZDNDc0QzZDQjkxMUYwOUFFNUZDNzBCMzIyRjgwNyIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PvArxh0AAAAGUExURQAA/wAAAHtivz4AAAAjSURBVHja7MGBAAAAAMOg+VNf4QBVAQAAAAAAAAAAAI8JMAAndAABi7SX2gAAAABJRU5ErkJggg==';
+
+const setup = {
+    options: { temperature: 0 },
+    config: { debug: false, max_history: 2 }
+};
+
+describe('Live Integration Tests', function () {
+    // Increase timeout for real API calls
+    this.timeout(30000);
+
+    describe('Image Processing', function () {
+
+        it('should process images with OpenAI GPT-5nano', async function () {
+            const model = ModelMix.new(setup).gpt5nano();
+
+            model.addImageFromUrl(blueSquareBase64)
+                .addText('What color is this image? Answer in one word only.');
+
+            const response = await model.message();
+
+            console.log(`OpenAI GPT-4o response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('blue');
+        });
+
+        it('should process images with Anthropic Claude', async function () {
+            const model = ModelMix.new(setup).sonnet35();
+
+            model.addImageFromUrl(blueSquareBase64)
+                .addText('What color is this image? Answer in one word only.');
+
+            const response = await model.message();
+            console.log(`Anthropic Claude response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('blue');
+        });
+
+        it('should process images with Google Gemini', async function () {
+            const model = ModelMix.new(setup).gemini25flash();
+
+            model.addImageFromUrl(blueSquareBase64)
+                .addText('What color is this image? Answer in one word only.');
+
+            const response = await model.message();
+            console.log(`Google Gemini response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('blue');
+        });
+
+    });
+
+    describe('JSON Structured Output', function () {
+
+        it('should return structured JSON with OpenAI', async function () {
+            const model = ModelMix.new(setup).gpt5mini();
+
+            model.addText('Generate information about a fictional character.');
+
+            const result = await model.json({
+                name: "John Doe",
+                age: 30,
+                occupation: "Engineer",
+                skills: ["JavaScript", "Python"]
+            }, {}, { addNote: true });
+
+            console.log(`OpenAI JSON result:`, result);
+
+            expect(result).to.be.an('object');
+            expect(result).to.have.property('name');
+            expect(result).to.have.property('age');
+            expect(result).to.have.property('occupation');
+            expect(result).to.have.property('skills');
+            expect(result.skills).to.be.an('array');
+        });
+
+        it('should return structured JSON with Sonnet Think', async function () {
+            const model = ModelMix.new(setup).sonnet4think();
+
+            model.addText('Generate information about a fictional city.');
+
+            const result = await model.json({
+                name: "Springfield",
+                population: 50000,
+                country: "USA",
+                attractions: ["Museum", "Park"]
+            });
+
+            console.log(`Anthropic JSON result:`, result);
+
+            expect(result).to.be.an('object');
+            expect(result).to.have.property('name');
+            expect(result).to.have.property('population');
+            expect(result).to.have.property('country');
+            expect(result).to.have.property('attractions');
+            expect(result.attractions).to.be.an('array');
+        });
+
+        it('should return structured JSON with Google Gemini', async function () {
+            const model = ModelMix.new(setup).gemini25flash();
+
+            model.addText('Generate information about a fictional city.');
+
+            const result = await model.json({
+                name: "Springfield",
+                population: 50000,
+                country: "USA",
+                attractions: ["Museum", "Park"]
+            });
+
+            console.log(`Google Gemini JSON result:`, result);
+
+            expect(result).to.be.an('object');
+            expect(result).to.have.property('name');
+            expect(result).to.have.property('population');
+            expect(result).to.have.property('country');
+            expect(result).to.have.property('attractions');
+            expect(result.attractions).to.be.an('array');
+        });
+
+
+    });
+
+    describe('Model Fallback', function () {
+
+        it('should fallback from OpenAI to Anthropic', async function () {
+            // Create a model chain: non-existent model -> Claude
+            const model = ModelMix.new(setup)
+                .attach('non-existent-model', new MixOpenAI())
+                .sonnet4();
+
+            model.addText('Say "fallback test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`Fallback test result: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('fallback test successful');
+        });
+
+        it('should fallback from Anthropic to OpenAI', async function () {
+            // Create a model chain: non-existent model -> Claude
+            const model = ModelMix.new(setup)
+                .attach('non-existent-model', new MixAnthropic())
+                .gpt41nano();
+
+            model.addText('Say "fallback test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`Fallback test result: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('fallback test successful');
+        });
+
+    });
+
+    describe('Additional Model Tests', function () {
+
+        it('should work with Scout model', async function () {
+            const model = ModelMix.new(setup).scout();
+
+            model.addText('Say "scout test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`Scout response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('scout test successful');
+        });
+
+        it('should work with KimiK2 model', async function () {
+            const model = ModelMix.new(setup).kimiK2();
+
+            model.addText('Say "kimik2 test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`KimiK2 response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('kimik2 test successful');
+        });
+
+        it('should work with GPT-OSS model', async function () {
+            const model = ModelMix.new(setup).gptOss();
+
+            model.addText('Say "gptoss test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`GPT-OSS response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('gptoss test successful');
+        });
+
+        it('should work with Grok3Mini model', async function () {
+            const model = ModelMix.new(setup).grok3mini();
+
+            model.addText('Say "grok3mini test successful" and nothing else.');
+
+            const response = await model.message();
+            console.log(`Grok3Mini response: ${response}`);
+
+            expect(response).to.be.a('string');
+            expect(response.toLowerCase()).to.include('grok3mini test successful');
+        });
+
+    });
+
+    describe('Image Processing with JSON Output', function () {
+
+        it('should process images and return JSON with Maverick', async function () {
+            const model = ModelMix.new(setup).maverick();
+            model.addImage(path.join(fixturesPath, 'img.png'))
+                .addText('Analyze this image and provide details in JSON format.');
+
+            const result = await model.json({
+                color: "string",
+                shape: "string",
+                description: "string"
+            });
+
+            console.log(`Scout image JSON result:`, result);
+
+            expect(result).to.be.an('object');
+            expect(result).to.have.property('color');
+            expect(result).to.have.property('shape');
+            expect(result).to.have.property('description');
+            expect(result.color.toLowerCase()).to.include('blue');
+        });
+
+        it('should process images and return JSON with Grok 4', async function () {
+            const model = ModelMix.new(setup).grok4();
+
+            model.addImageFromUrl(blueSquareBase64)
+                .addText('Analyze this image and provide details in JSON format.');
+
+            const result = await model.json({
+                color: "string",
+                shape: "string",
+                description: "string"
+            });
+
+            console.log(`Grok3Mini image JSON result:`, result);
+
+            expect(result).to.be.an('object');
+            expect(result).to.have.property('color');
+            expect(result).to.have.property('shape');
+            expect(result).to.have.property('description');
+            expect(result.color.toLowerCase()).to.include('blue');
+        });
+
+    });
+
+    describe('JSON Structured Output for New Models', function () {
+
+        it('should return structured JSON with Scout', async function () {
+            const model = ModelMix.new(setup).scout();
+
+            model.addText('Generate information about a fictional animal.');
+
+            const result = await model.json({
+                name: "Dragon",
+                type: "Mythical",
+                abilities: ["Fire breathing", "Flight"],
+                habitat: "Mountains"
+            });
+
+            console.log(`Scout 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('abilities');
+            expect(result).to.have.property('habitat');
+            expect(result.abilities).to.be.an('array');
+        });
+
+        it('should return structured JSON with KimiK2', async function () {
+            const model = ModelMix.new(setup).kimiK2();
+
+            model.addText('Generate information about a fictional vehicle.');
+
+            const result = await model.json({
+                name: "Flying Car",
+                type: "Transportation",
+                features: ["Anti-gravity", "Auto-pilot"],
+                manufacturer: "Future Motors"
+            });
+
+            console.log(`KimiK2 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('features');
+            expect(result).to.have.property('manufacturer');
+            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();
+
+            model.addText('Generate information about a fictional technology.');
+
+            const result = await model.json({
+                name: "Quantum Computer",
+                type: "Computing",
+                applications: ["Cryptography", "Simulation"],
+                power: "1000 qubits"
+            });
+
+            console.log(`Grok3Mini 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('applications');
+            expect(result).to.have.property('power');
+            expect(result.applications).to.be.an('array');
+        });
+
+    });
+
+
+});

package/test/mocha.opts

@@ -0,0 +1,5 @@
+--timeout 10000
+--recursive
+--require test/setup.js
+--reporter spec
+--bail false