modelmix 3.0.0 → 3.0.4

package/README.md

@@ -106,6 +106,16 @@ Here's a quick example to get you started:
     console.log(await gpt.message());
     ```
 
+    #### gpt-4.1-nano (json)
+    ```javascript
+    console.log("\n" + '--------| gpt-4.1-nano |--------');
+    const gpt = mmix.create('gpt-4.1-nano', { options: { temperature: 0 } }).addText("Have you ever eaten a {animal}?");
+    gpt.replace({ '{animal}': 'cat' });
+    const schemaExample = { time: '24:00:00', message: 'Hello' };
+    const schemaDescription = { time: 'Time in format HH:MM:SS' }; // optional
+    console.log(await gpt.json(schemaExample, schemaDescription));
+    ```
+
     #### claude-3-5-sonnet-20240620 (writer)
     ```javascript
     const writer = mmix.create('claude-3-5-sonnet-20240620', { options: { temperature: 0.5 } });
@@ -289,6 +299,18 @@ new ModelMix(args = { options: {}, config: {} })
 - `message()`: Sends the message and returns the response.
 - `raw()`: Sends the message and returns the raw response data.
 - `stream(callback)`: Sends the message and streams the response, invoking the callback with each streamed part.
+- `json(schemaExample, descriptions = {})`: Forces the model to return a response in a specific JSON format.
+  - `schemaExample`: Optional example of the JSON structure to be returned.
+  - `descriptions`: Optional descriptions for each field in the JSON structure
+  - Returns a Promise that resolves to the structured JSON response
+  - Example:
+    ```javascript
+    const response = await handler.json(
+      { time: '24:00:00', message: 'Hello' },
+      { time: 'Time in format HH:MM:SS' }
+    );
+    ```
+- `block({ addText = true })`: Forces the model to return a response in a specific block format.
 
 ### MixCustom Class Overview
 

package/demo/demo.mjs

@@ -1,6 +1,7 @@
 import 'dotenv/config';
 import { ModelMix, MixOpenAI, MixAnthropic, MixPerplexity, MixOllama } from '../index.js';
 
+
 const mmix = new ModelMix({
     options: {
         max_tokens: 200,
@@ -20,7 +21,7 @@ mmix.attach(new MixPerplexity({
         apiKey: process.env.PPLX_API_KEY,
         system: 'You are my personal assistant.'
     },
-    
+
 }));
 mmix.attach(new MixOllama({
     config: {
@@ -33,16 +34,16 @@ mmix.attach(new MixOllama({
 
 mmix.replace({ '{name}': 'ALF' });
 
-console.log("\n" + '--------| o3-mini |--------');
-const gpt = mmix.create('o3-mini', { options: { temperature: 0 } }).addText("Have you ever eaten a {animal}?");
+console.log("\n" + '--------| gpt-4.1-nano |--------');
+const gpt = mmix.create('gpt-4.1-nano', { options: { temperature: 0 } }).addText("Have you ever eaten a {animal}?");
 gpt.replace({ '{animal}': 'cat' });
-console.log(await gpt.message());
+console.log(await gpt.json({ time: '24:00:00', message: 'Hello' }, { time: 'Time in format HH:MM:SS' }));
 
-console.log("\n" + '--------| claude-3-5-sonnet-20240620 |--------');
-const claude = mmix.create('claude-3-5-sonnet-20240620', { options: { temperature: 0 } });
-claude.addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg');
-const imageDescription = await claude.addText('describe the image').message();
-console.log(imageDescription);
+// console.log("\n" + '--------| claude-3-5-sonnet-20240620 |--------');
+// const claude = mmix.create('claude-3-5-sonnet-20240620', { options: { temperature: 0 } });
+// claude.addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg');
+// const imageDescription = await claude.addText('describe the image').message();
+// console.log(imageDescription);
 
 console.log("\n" + '--------| claude-3-7-sonnet-20250219 |--------');
 const writer = mmix.create('claude-3-7-sonnet-20250219', { options: { temperature: 0.5 } });

package/index.js

@@ -4,6 +4,7 @@ const mime = require('mime-types');
 const log = require('lemonlog')('ModelMix');
 const Bottleneck = require('bottleneck');
 const path = require('path');
+const generateJsonSchema = require('./schema');
 
 class ModelMix {
     constructor(args = { options: {}, config: {} }) {
@@ -232,6 +233,24 @@ class MessageHandler {
         return response.message;
     }
 
+    async json(schemaExample = null, schemaDescription = {}) {
+        this.options.response_format = { type: "json_object" };
+        if (schemaExample) {
+            const schema = generateJsonSchema(schemaExample, schemaDescription);
+            this.addText("Output expected JSON Schema: \n```\n" + JSON.stringify(schema, null, 2) + "\n```");
+        }
+        return JSON.parse(await this.message());
+    }
+
+    async block({ addText = true } = {}) {
+        if (addText) {
+            this.addText("Output expected between triple backtick block code tags: \n```\n");
+        }
+        const response = await this.message();
+        const block = response.match(/```(?:\w+)?\s*([\s\S]*?)```/);
+        return block ? block[1].trim() : response;
+    }
+
     async raw() {
         this.options.stream = false;
         return this.execute();
@@ -323,7 +342,7 @@ class MessageHandler {
 
                         // Create a completely new handler with the fallback model
                         const nextHandler = this.mix.create(
-                            [nextModelKey, ...this.fallbackModels.slice(1)], 
+                            [nextModelKey, ...this.fallbackModels.slice(1)],
                             {
                                 options: {
                                     // Keep only generic options, not model-specific ones
@@ -334,21 +353,21 @@ class MessageHandler {
                                 }
                             }
                         );
-                        
+
                         // Assign all messages directly
                         nextHandler.messages = [...this.messages];
-                        
+
                         // Keep same system and replacements
                         nextHandler.setSystem(this.config.system);
                         if (this.config.replace) {
                             nextHandler.replace(this.config.replace);
                         }
-                        
+
                         await nextHandler.prepareMessages();
-                        
-                        const result = await nextHandler.modelEntry.create({ 
-                            options: nextHandler.options, 
-                            config: nextHandler.config 
+
+                        const result = await nextHandler.modelEntry.create({
+                            options: nextHandler.options,
+                            config: nextHandler.config
                         });
                         nextHandler.messages.push({ role: "assistant", content: result.message });
                         return result;
@@ -491,7 +510,7 @@ class MixOpenAI extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.openai.com/v1/chat/completions',
-            prefix: ['gpt', 'ft:', 'o3', 'o1'],
+            prefix: ['gpt', 'ft:', 'o'],
             apiKey: process.env.OPENAI_API_KEY,
             ...customConfig
         });
@@ -649,7 +668,7 @@ class MixGrok extends MixOpenAI {
         return super.getDefaultConfig({
             url: 'https://api.x.ai/v1/chat/completions',
             prefix: ['grok'],
-            apiKey: process.env.XAI_API_KEY,            
+            apiKey: process.env.XAI_API_KEY,
             ...customConfig
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "3.0.0",
+  "version": "3.0.4",
   "description": "🧬 ModelMix - Unified API for Diverse AI LLM.",
   "main": "index.js",
   "repository": {
@@ -29,7 +29,7 @@
     "together",
     "nano",
     "deepseek",
-    "o3",
+    "o4",
     "4.1",
     "nousresearch",
     "reasoning",

package/schema.js

@@ -0,0 +1,105 @@
+function generateJsonSchema(example, descriptions = {}) {
+    function detectType(key, value) {
+        if (value === null) return { type: 'null' };
+        if (typeof value === 'boolean') return { type: 'boolean' };
+        if (typeof value === 'number') {
+            return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
+        }
+        if (typeof value === 'string') {
+            const schema = { type: 'string' };
+            if (/^\S+@\S+\.\S+$/.test(value)) {
+                schema.format = 'email';
+            } else if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+                schema.format = 'date';
+                if (!descriptions[key]) {
+                    schema.description = 'Date in format YYYY-MM-DD';
+                }
+            } else if (/^([01]?\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?$/.test(value)) {
+                schema.format = 'time';
+                if (!descriptions[key]) {
+                    const hasSeconds = value.split(':').length === 3;
+                    schema.description = hasSeconds ?
+                        'Time in format HH:MM:SS' :
+                        'Time in format HH:MM';
+                }
+            }
+            return schema;
+        }
+        if (Array.isArray(value)) {
+            if (value.length > 0 && typeof value[0] === 'object' && !Array.isArray(value[0])) {
+                // Es un array de objetos
+                return {
+                    type: 'array',
+                    items: generateJsonSchema(value[0], descriptions[key] || {})
+                };
+            } else {
+                // Es un array de valores simples
+                return {
+                    type: 'array',
+                    items: value.length > 0 ? detectType(key, value[0]) : {}
+                };
+            }
+        }
+        if (typeof value === 'object') {
+            return generateJsonSchema(value, descriptions[key] || {});
+        }
+        return {};
+    }
+
+    if (Array.isArray(example)) {
+        // Si el ejemplo raíz es un array
+        return {
+            type: 'array',
+            items: generateJsonSchema(example[0], descriptions)
+        };
+    }
+
+    const schema = {
+        type: 'object',
+        properties: {},
+        required: []
+    };
+
+    for (const key in example) {
+        const fieldSchema = detectType(key, example[key]);
+
+        if (descriptions[key] && typeof fieldSchema === 'object') {
+            fieldSchema.description = descriptions[key];
+        }
+
+        schema.properties[key] = fieldSchema;
+        schema.required.push(key);
+    }
+
+    return schema;
+}
+
+module.exports = generateJsonSchema;
+
+// const example = {
+//     name: 'Alice',
+//     age: 30,
+//     email: 'alice@example.com',
+//     birthDate: '1990-01-01',
+//     isAdmin: false,
+//     preferences: {
+//         theme: 'dark',
+//         notifications: true
+//     },
+//     tags: ['admin', 'user']
+// };
+
+// const descriptions = {
+//     name: 'Full name of the user',
+//     age: 'Age must be 0 or greater',
+//     email: 'User email address',
+//     // birthDate: 'User birth date in YYYY-MM-DD format',
+//     preferences: {
+//         theme: 'Theme preference (light/dark)',
+//         notifications: 'Whether notifications are enabled'
+//     }
+// };
+
+// const schema = generateJsonSchema(example);
+
+// console.log(JSON.stringify(schema, null, 2));