modelmix 4.4.4 → 4.4.7

package/test/json.test.js

@@ -181,6 +181,163 @@ describe('JSON Schema and Structured Output Tests', () => {
         });
     });
 
+    describe('Enhanced Descriptor Descriptions', () => {
+        it('should support required: false (not in required + nullable)', () => {
+            const example = { name: 'Alice', nickname: 'Ali' };
+            const descriptions = {
+                name: 'Full name',
+                nickname: { description: 'Optional nickname', required: false }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.required).to.deep.equal(['name']);
+            expect(schema.properties.nickname).to.deep.equal({
+                type: ['string', 'null'],
+                description: 'Optional nickname'
+            });
+            expect(schema.properties.name).to.deep.equal({
+                type: 'string',
+                description: 'Full name'
+            });
+        });
+
+        it('should support enum', () => {
+            const example = { status: 'active' };
+            const descriptions = {
+                status: { description: 'Account status', enum: ['active', 'inactive', 'banned'] }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.status).to.deep.equal({
+                type: 'string',
+                description: 'Account status',
+                enum: ['active', 'inactive', 'banned']
+            });
+            expect(schema.required).to.deep.equal(['status']);
+        });
+
+        it('should make type nullable when enum includes null', () => {
+            const example = { sex: 'm' };
+            const descriptions = {
+                sex: { description: 'Gender', enum: ['m', 'f', null] }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.sex).to.deep.equal({
+                type: ['string', 'null'],
+                description: 'Gender',
+                enum: ['m', 'f', null]
+            });
+        });
+
+        it('should support default value', () => {
+            const example = { theme: 'light' };
+            const descriptions = {
+                theme: { description: 'UI theme', default: 'light', enum: ['light', 'dark'] }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.theme).to.deep.equal({
+                type: 'string',
+                description: 'UI theme',
+                default: 'light',
+                enum: ['light', 'dark']
+            });
+        });
+
+        it('should mix string and descriptor descriptions', () => {
+            const example = { name: 'martin', age: 22, sex: 'm' };
+            const descriptions = {
+                name: { description: 'Name of the actor', required: false },
+                age: 'Age of the actor',
+                sex: { description: 'Gender', enum: ['m', 'f', null], default: 'm' }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.required).to.deep.equal(['age', 'sex']);
+            expect(schema.properties.name).to.deep.equal({
+                type: ['string', 'null'],
+                description: 'Name of the actor'
+            });
+            expect(schema.properties.age).to.deep.equal({
+                type: 'integer',
+                description: 'Age of the actor'
+            });
+            expect(schema.properties.sex).to.deep.equal({
+                type: ['string', 'null'],
+                description: 'Gender',
+                enum: ['m', 'f', null],
+                default: 'm'
+            });
+        });
+
+        it('should not apply descriptor as nested descriptions for objects', () => {
+            const example = { user: { name: 'Alice', age: 30 } };
+            const descriptions = {
+                user: { description: 'User details', required: false }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.required).to.deep.equal([]);
+            expect(schema.properties.user.description).to.equal('User details');
+            expect(schema.properties.user.properties.name).to.deep.equal({ type: 'string' });
+            expect(schema.properties.user.properties.age).to.deep.equal({ type: 'integer' });
+        });
+
+        it('should pass nested descriptions correctly for objects', () => {
+            const example = { user: { name: 'Alice', age: 30 } };
+            const descriptions = {
+                user: { name: 'User name', age: 'User age' }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.user.properties.name).to.deep.equal({
+                type: 'string',
+                description: 'User name'
+            });
+            expect(schema.properties.user.properties.age).to.deep.equal({
+                type: 'integer',
+                description: 'User age'
+            });
+        });
+
+        it('should handle array descriptions in array format', () => {
+            const example = {
+                countries: [{ name: 'France', capital: 'Paris' }]
+            };
+            const descriptions = {
+                countries: [{ name: 'Country name', capital: 'Capital city' }]
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.countries.type).to.equal('array');
+            expect(schema.properties.countries.items.properties.name.description).to.equal('Country name');
+            expect(schema.properties.countries.items.properties.capital.description).to.equal('Capital city');
+        });
+
+        it('should handle descriptor for array field itself', () => {
+            const example = { tags: ['admin'] };
+            const descriptions = {
+                tags: { description: 'User tags', required: false }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            expect(schema.properties.tags.description).to.equal('User tags');
+            expect(schema.required).to.deep.equal([]);
+        });
+
+        it('should not double-add null to type', () => {
+            const example = { status: 'active' };
+            const descriptions = {
+                status: { required: false, enum: ['active', null] }
+            };
+            const schema = generateJsonSchema(example, descriptions);
+
+            const nullCount = schema.properties.status.type.filter(t => t === 'null').length;
+            expect(nullCount).to.equal(1);
+        });
+    });
+
     describe('ModelMix JSON Output', () => {
         let model;
 
@@ -198,7 +355,7 @@ describe('JSON Schema and Structured Output Tests', () => {
                 }]
             };
             
-            model.gpt41().addText('List 3 countries');
+            model.gpt52().addText('List 3 countries');
             
             // Mock the API response
             nock('https://api.openai.com')
@@ -249,7 +406,7 @@ describe('JSON Schema and Structured Output Tests', () => {
                 }
             };
 
-            model.sonnet4().addText('Generate user data');
+            model.sonnet46().addText('Generate user data');
             
             // Mock the API response
             nock('https://api.anthropic.com')
@@ -270,7 +427,7 @@ describe('JSON Schema and Structured Output Tests', () => {
         });
 
         it('should handle JSON parsing errors gracefully', async () => {
-            model.gpt41().addText('Generate invalid JSON');
+            model.gpt52().addText('Generate invalid JSON');
             
             // Mock invalid JSON response
             nock('https://api.openai.com')
@@ -291,5 +448,33 @@ describe('JSON Schema and Structured Output Tests', () => {
                 expect(error.message).to.include('JSON');
             }
         });
+
+        it('should auto-wrap top-level array and unwrap on return', async () => {
+            model.gpt52().addText('List 3 countries');
+
+            nock('https://api.openai.com')
+                .post('/v1/chat/completions')
+                .reply(200, {
+                    choices: [{
+                        message: {
+                            role: 'assistant',
+                            content: JSON.stringify({
+                                out: [
+                                    { name: 'France' },
+                                    { name: 'Germany' },
+                                    { name: 'Spain' }
+                                ]
+                            })
+                        }
+                    }]
+                });
+
+            const result = await model.json([{ name: 'France' }]);
+
+            expect(result).to.be.an('array');
+            expect(result).to.have.length(3);
+            expect(result[0]).to.have.property('name', 'France');
+            expect(result[2]).to.have.property('name', 'Spain');
+        });
     });
 });

package/test/live.mcp.js

@@ -31,8 +31,8 @@ describe('Live MCP Integration Tests', function () {
 
     describe('Basic MCP Tool Integration', function () {
 
-        it('should use custom MCP tools with GPT-4.1', async function () {
-            const model = ModelMix.new(setup).gpt41();
+        it('should use custom MCP tools with GPT-5.2', async function () {
+            const model = ModelMix.new(setup).gpt52();
 
             // Add custom calculator tool
             model.addTool({
@@ -68,8 +68,8 @@ describe('Live MCP Integration Tests', function () {
             expect(response).to.include('345');
         });
 
-        it('should use custom MCP tools with Claude Sonnet 4', async function () {
-            const model = ModelMix.new(setup).sonnet4();
+        it('should use custom MCP tools with Claude Sonnet 4.6', async function () {
+            const model = ModelMix.new(setup).sonnet46();
 
             // Add time tool
             model.addTool({
@@ -505,7 +505,7 @@ describe('Live MCP Integration Tests', function () {
             const models = [
                 { name: 'GPT-5 Mini', model: ModelMix.new(setup).gpt5mini() },
                 { name: 'GPT-5 Nano', model: ModelMix.new(setup).gpt5nano() },
-                { name: 'GPT-4.1', model: ModelMix.new(setup).gpt41() }
+                { name: 'GPT-5.2', model: ModelMix.new(setup).gpt52() }
             ];
 
             const results = [];
@@ -528,8 +528,8 @@ 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).sonnet4() },
-                { name: 'Sonnet 4.5', model: ModelMix.new(setup).sonnet45() },
+                { name: 'Sonnet 4', model: ModelMix.new(setup).sonnet46() },
+                { name: 'Sonnet 4.6', model: ModelMix.new(setup).sonnet46() },
                 { name: 'Haiku 4.5', model: ModelMix.new(setup).haiku45() }
             ];
 

package/test/live.test.js

@@ -41,14 +41,14 @@ describe('Live Integration Tests', function () {
 
             const response = await model.message();
 
-            console.log(`OpenAI GPT-4o response: ${response}`);
+            console.log(`OpenAI GPT-5.2 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).sonnet45();
+        it('should process images with Anthropic Sonnet 4.6', async function () {
+            const model = ModelMix.new(setup).sonnet46();
 
             model.addImageFromUrl(blueSquareBase64)
                 .addText('What color is this image? Answer in one word only.');
@@ -61,7 +61,7 @@ describe('Live Integration Tests', function () {
         });
 
         it('should process images with Google Gemini', async function () {
-            const model = ModelMix.new(setup).gemini25flash();
+            const model = ModelMix.new(setup).gemini3flash();
 
             model.addImageFromUrl(blueSquareBase64)
                 .addText('What color is this image? Answer in one word only.');
@@ -99,8 +99,8 @@ describe('Live Integration Tests', function () {
             expect(result.skills).to.be.an('array');
         });
 
-        it('should return structured JSON with Sonnet 4.5 thinking', async function () {
-            const model = ModelMix.new(setup).sonnet45think();
+        it('should return structured JSON with Sonnet 4.6 thinking', async function () {
+            const model = ModelMix.new(setup).sonnet46think();
 
             model.addText('Generate information about a fictional city.');
 
@@ -122,7 +122,7 @@ describe('Live Integration Tests', function () {
         });
 
         it('should return structured JSON with Google Gemini', async function () {
-            const model = ModelMix.new(setup).gemini25flash();
+            const model = ModelMix.new(setup).gemini3flash();
 
             model.addText('Generate information about a fictional city.');
 
@@ -152,7 +152,7 @@ describe('Live Integration Tests', function () {
             // Create a model chain: non-existent model -> Claude
             const model = ModelMix.new(setup)
                 .attach('non-existent-model', new MixOpenAI())
-                .sonnet4();
+                .sonnet46();
 
             model.addText('Say "fallback test successful" and nothing else.');
 

package/test/templates.test.js

@@ -27,7 +27,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should replace simple template variables', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replace({
                     '{{name}}': 'Alice',
                     '{{age}}': '30',
@@ -56,7 +56,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should handle multiple template replacements', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replace({ '{{greeting}}': 'Hello' })
                 .replace({ '{{name}}': 'Bob' })
                 .replace({ '{{action}}': 'welcome' })
@@ -82,7 +82,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should handle nested template objects', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replace({
                     '{{user_name}}': 'Charlie',
                     '{{user_role}}': 'admin',
@@ -111,7 +111,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should preserve unreplaced templates', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replace({ '{{name}}': 'David' })
                 .addText('Hello {{name}}, your ID is {{user_id}} and status is {{status}}');
 
@@ -135,7 +135,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should handle empty and special character replacements', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replace({
                     '{{empty}}': '',
                     '{{special}}': 'Hello & "World" <test>',
@@ -175,7 +175,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should load and replace from template file', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{template}}', path.join(fixturesPath, 'template.txt'))
                 .replace({
                     '{{name}}': 'Eve',
@@ -214,7 +214,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should load and process JSON data file', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{data}}', path.join(fixturesPath, 'data.json'))
                 .addText('Process this data: {{data}}');
 
@@ -246,7 +246,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should handle file loading errors gracefully', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{missing}}', path.join(fixturesPath, 'nonexistent.txt'))
                 .addText('This should contain: {{missing}}');
 
@@ -271,7 +271,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should handle multiple file replacements', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{template}}', path.join(fixturesPath, 'template.txt'))
                 .replaceKeyFromFile('{{data}}', path.join(fixturesPath, 'data.json'))
                 .replace({
@@ -315,7 +315,7 @@ describe('Template and File Operations Tests', () => {
         it('should handle relative and absolute paths', async () => {
             const absolutePath = path.resolve(fixturesPath, 'template.txt');
 
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{absolute}}', absolutePath)
                 .replace({
                     '{{name}}': 'Grace',
@@ -362,7 +362,7 @@ describe('Template and File Operations Tests', () => {
         });
 
         it('should combine file loading with template replacement in complex scenarios', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{user_data}}', path.join(fixturesPath, 'data.json'))
                 .replace({
                     '{{action}}': 'analyze',
@@ -402,7 +402,7 @@ describe('Template and File Operations Tests', () => {
                 roles: ['admin', 'user']
             };
 
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{data}}', path.join(fixturesPath, 'data.json'))
                 .replace({ '{{instruction}}': 'Count active users by role' })
                 .addText('{{instruction}} from this data: {{data}}');
@@ -447,16 +447,16 @@ describe('Template and File Operations Tests', () => {
 
         it('should handle template replacement errors gracefully', () => {
             expect(() => {
-                model.gpt41().replace(null);
+                model.gpt51().replace(null);
             }).to.not.throw();
 
             expect(() => {
-                model.gpt41().replace(undefined);
+                model.gpt51().replace(undefined);
             }).to.not.throw();
         });
 
         it('should handle file reading errors without crashing', async () => {
-            model.gpt41()
+            model.gpt51()
                 .replaceKeyFromFile('{{bad_file}}', '/path/that/does/not/exist.txt')
                 .addText('Content: {{bad_file}}');
 

package/test/tokens.test.js

@@ -1,8 +1,23 @@
 import { expect } from 'chai';
 import { ModelMix } from '../index.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const nock = require('nock');
 
 describe('Token Usage Tracking', () => {
 
+    // Ensure nock doesn't interfere with live requests via MockHttpSocket
+    before(function() {
+        nock.cleanAll();
+        nock.restore();
+    });
+
+    after(function() {
+        // Re-activate nock for any subsequent test suites
+        nock.activate();
+    });
+
     it('should track tokens in OpenAI response', async function () {
         this.timeout(30000);
 
@@ -30,7 +45,7 @@ describe('Token Usage Tracking', () => {
         this.timeout(30000);
 
         const model = ModelMix.new()
-            .haiku35()
+            .haiku45()
             .addText('Say hi');
 
         const result = await model.raw();
@@ -49,7 +64,7 @@ describe('Token Usage Tracking', () => {
         this.timeout(30000);
 
         const model = ModelMix.new()
-            .gemini25flash()
+            .gemini3flash()
             .addText('Say hi');
 
         const result = await model.raw();
@@ -110,8 +125,8 @@ describe('Token Usage Tracking', () => {
 
         const providers = [
             { name: 'OpenAI', create: (m) => m.gpt5nano() },
-            { name: 'Anthropic', create: (m) => m.haiku35() },
-            { name: 'Google', create: (m) => m.gemini25flash() }
+            { name: 'Anthropic', create: (m) => m.haiku45() },
+            { name: 'Google', create: (m) => m.gemini3flash() }
         ];
 
         for (const provider of providers) {