modelmix 3.1.6 → 3.2.2

package/README.md

@@ -2,13 +2,16 @@
 
 **ModelMix** is a versatile module that enables seamless integration of various language models from different providers through a unified interface. With ModelMix, you can effortlessly manage and utilize multiple AI models while controlling request rates to avoid provider restrictions.
 
+Are you one of those developers who wants to apply language models to everything? Do you need a reliable fallback system to ensure your application never fails? ModelMix is the answer! It allows you to chain multiple models together, automatically falling back to the next model if one fails, ensuring your application always gets a response.
+
 ## ✨ Features
 
 - **Unified Interface**: Interact with multiple AI models through a single, coherent API.
 - **Request Rate Control**: Manage the rate of requests to adhere to provider limitations using Bottleneck.
-- **Flexible Integration**: Easily integrate popular models like OpenAI, Anthropic, Perplexity, Groq, Together AI, Ollama, LM Studio or custom models.
+- **Flexible Integration**: Easily integrate popular models like OpenAI, Anthropic, Perplexity, Groq, Together AI, Ollama, LM Studio, Google Gemini or custom models.
 - **History Tracking**: Automatically logs the conversation history with model responses, allowing you to limit the number of historical messages with `max_history`.
 - **Model Fallbacks**: Automatically try different models if one fails or is unavailable.
+- **Chain Multiple Models**: Create powerful chains of models that work together, with automatic fallback if one fails.
 
 ## 📦 Installation
 
@@ -18,7 +21,7 @@ First, install the ModelMix package:
 npm install modelmix
 ```
 
-Optional: install dotenv to manage environment variables:
+Recommended: install dotenv to manage environment variables:
 
 ```bash
 npm install dotenv
@@ -35,129 +38,49 @@ Here's a quick example to get you started:
     PPLX_API_KEY="your_perplexity_api_key"
     GROQ_API_KEY="your_groq_api_key"
     TOGETHER_API_KEY="your_together_api_key"
+    GOOGLE_API_KEY="your_google_api_key"
     ```
 
 2. **Create and configure your models**:
 
-    ```javascript
-    import 'dotenv/config';
-    import { ModelMix, MixOpenAI, MixAnthropic, MixPerplexity, MixOllama, MixTogether } from 'modelmix';
-
-    const env = process.env;
-
-    const mmix = new ModelMix({
-        options: {
-            max_tokens: 200,
-        },
-        config: {
-            system: "You are {name} from Melmac.",
-            max_history: 2,
-            bottleneck: { maxConcurrent: 2 },
-            debug: true
-        }
-    });
-
-    mmix.replace({ '{name}': 'ALF' });
-
-    mmix.attach(new MixOpenAI({ config: { apiKey: env.OPENAI_API_KEY } }));
-    mmix.attach(new MixAnthropic()); // it will use the default apiKey from process.env
-    mmix.attach(new MixPerplexity({
-        config: {
-            apiKey: env.PPLX_API_KEY
-        },
-        options: {
-            system: "You are my personal assistant."
-        }
-    }));
-    mmix.attach(new MixOllama({
-        config: {
-            url: 'http://localhost:11434/api/chat',
-            prefix: ['llava'],
-        },
-        options: {
-            temperature: 0.5,
-        }
-    }));
-    mmix.attach(new MixTogether());
-    ```
-
-3. **Generate responses from different models**:
-
-    #### Model Fallbacks
-    ```javascript
-    // Create a message handler with multiple fallback models
-    const handler = mmix.create(['grok-2-latest', 'claude-3-7-sonnet-20250219']);
-    
-    // If the first model (grok-2-latest) fails or is unavailable,
-    // ModelMix will automatically try the next model (claude-3-7-sonnet)
-    const response = await handler.addText('do you like cats?').message();
-    ```
-
-    The `create()` method accepts either a single model name as a string or an array of model names. When an array is provided, ModelMix will attempt to use each model in order until a successful response is received. This is useful for:
-    - Implementing fallback options when a primary model is unavailable
-    - Load balancing across different providers
-    - Ensuring high availability in your application
-
-    #### gpt-4o-mini
-    ```javascript
-    const gpt = mmix.create('gpt-4o-mini', { options: { temperature: 0 } });
-    gpt.addText("Have you ever eaten a {animal}?");
-    gpt.replace({ '{animal}': 'cat' });
-    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 } });
-    writer.setSystem('You are a writer like Stephen King'); // or setSystemFromFile
-    writer.replace({ '{story_title}': 'The Mysterious Package' })
-    // or write.replaceKeyFromFile('{story_title}', './title.md');
-    const story = await writer.addTextFromFile('./prompt.md').message();
-    console.log(story);
-    ```
-    #### claude-3-5-sonnet-20240620 (image)
-    ```javascript
-    console.log("\n" + '--------|  |--------');
-    const claude = mmix.create('claude-3-5-sonnet-20240620', { options: { temperature: 0 } });
-    claude.addImage("./watson.jpg"); // or claude.addImageFromUrl(url)
-    const imageDescription = await claude.addText("Describe the image").message();
-    console.log(imageDescription);
-    ```
-
-    #### pplx-70b-online
-    ```javascript
-    const pplx = mmix.create('pplx-70b-online', { config: { max_tokens: 500 } });
-    pplx.addText('How much is ETH trading in USD?');
-    const news = await pplx.addText('What are the 3 most recent Ethereum news?').message();
-    console.log(news);
-    ```
-
-    #### ollama (llava:latest)
-    ```javascript
-    await mmix.create('llava:latest')
-        .addImage("./watson.jpg")
-        .addText("What is the predominant color?")
-        .stream((data) => { console.log(data.message); });
-    ```
+```javascript
+import 'dotenv/config';
+import { ModelMix } from 'modelmix';
+
+// Basic setup with system prompt and debug mode
+const setup = {
+    config: {
+        system: "You are ALF, if they ask your name, respond with 'ALF'.",
+        debug: true
+    }
+};
+
+// Chain multiple models with automatic fallback
+const result = await ModelMix.create(setup)
+    .sonnet37think()
+    .o4mini({ config: { temperature: 0 } })
+    .gemini25proExp()
+    .gpt41nano()
+    .grok3mini()
+    .addText("What's your name?")
+    .message();
+
+console.log(result);
+
+// Get structured JSON responses
+const jsonResult = await ModelMix.create()
+    .sonnet37()
+    .addText("Name and capital of 3 South American countries.")
+    .json({ countries: [{ name: "", capital: "" }] });
+
+console.log(jsonResult);
+```
 
-    #### Together AI (deepseek-ai/DeepSeek-R1)
-    ```javascript
-    const together = mmix.create('deepseek-ai/DeepSeek-R1', { options: { temperature: 0.7 } });
-    together.addText('What are the main differences between Python and JavaScript?');
-    const comparison = await together.message();
-    console.log(comparison);
-    ```
-4. Find the files for this example at: [/ModelMix/demo](https://github.com/clasen/ModelMix/tree/master/demo).
+This pattern allows you to:
+- Chain multiple models together
+- Automatically fall back to the next model if one fails
+- Get structured JSON responses when needed
+- Keep your code clean and maintainable
 
 ## 🔄 Templating Methods
 
@@ -243,14 +166,14 @@ ModelMix now uses Bottleneck for efficient rate limiting of API requests. This i
 1. **Configuration**: Bottleneck is configured in the ModelMix constructor. You can customize the settings or use the default configuration:
 
     ```javascript
-    const mmix = new ModelMix({
+    const setup = {
         config: {
             bottleneck: {
                 maxConcurrent: 8,     // Maximum number of concurrent requests
                 minTime: 500          // Minimum time between requests (in ms)
             }
         }
-    });
+    };
     ```
 
 2. **Rate Limiting**: When you make a request using any of the attached models, Bottleneck automatically manages the request flow based on the configured settings.
@@ -282,6 +205,43 @@ new ModelMix(args = { options: {}, config: {} })
       - `reservoirRefreshInterval`: Reservoir refresh interval
     - ...(Additional configuration parameters can be added as needed)
 
+### Shorthand Methods
+
+ModelMix provides convenient shorthand methods for quickly accessing different AI models. Here's a comprehensive list of available methods:
+
+| Method             | Provider    | Model                          | Description                                  |
+| ------------------ | ----------- | ------------------------------ | -------------------------------------------- |
+| `gpt41()`          | OpenAI      | gpt-4.1                        | OpenAI's GPT-4.1 model                       |
+| `gpt41mini()`      | OpenAI      | gpt-4.1-mini                   | OpenAI's GPT-4.1 Mini model                  |
+| `gpt41nano()`      | OpenAI      | gpt-4.1-nano                   | OpenAI's GPT-4.1 Nano model                  |
+| `gpt4o()`          | OpenAI      | gpt-4o                         | OpenAI's GPT-4 Optimized model               |
+| `o4mini()`         | OpenAI      | o4-mini                        | OpenAI's O4 Mini model                       |
+| `o3()`             | OpenAI      | o3                             | OpenAI's O3 model                            |
+| `sonnet37()`       | Anthropic   | claude-3-7-sonnet-20250219     | Anthropic's Claude 3.7 Sonnet model          |
+| `sonnet37think()`  | Anthropic   | claude-3-7-sonnet-20250219     | Claude 3.7 Sonnet with thinking mode enabled |
+| `sonnet35()`       | Anthropic   | claude-3-5-sonnet-20241022     | Anthropic's Claude 3.5 Sonnet model          |
+| `haiku35()`        | Anthropic   | claude-3-5-haiku-20241022      | Anthropic's Claude 3.5 Haiku model           |
+| `gemini25flash()`  | Google      | gemini-2.5-flash-preview-04-17 | Google's Gemini 2.5 Flash model              |
+| `gemini25proExp()` | Google      | gemini-2.5-pro-exp-03-25       | Google's Gemini 2.5 Pro Experimental model   |
+| `gemini25pro()`    | Google      | gemini-2.5-pro-preview-05-06   | Google's Gemini 2.5 Pro model                |
+| `sonar()`          | Perplexity  | sonar-pro                      | Perplexity's Sonar Pro model                 |
+| `qwen3()`          | Together AI | Qwen/Qwen3-235B-A22B-fp8-tput  | Together AI's Qwen 3 model                   |
+| `grok2()`          | Grok        | grok-2-latest                  | Grok's latest version 2 model                |
+| `grok3()`          | Grok        | grok-3-beta                    | Grok's version 3 beta model                  |
+| `grok3mini()`      | Grok        | grok-3-mini-beta               | Grok's version 3 mini beta model             |
+| `scout()`          | Cerebras    | llama-4-scout-17b-16e-instruct | Cerebras' Llama 4 Scout model                |
+
+Each method accepts optional `options` and `config` parameters to customize the model's behavior. For example:
+
+```javascript
+const result = await ModelMix.create()
+    .sonnet37({ 
+        options: { temperature: 0.7 },
+        config: { system: "You are a helpful assistant" }
+    })
+    .message();
+```
+
 **Methods**
 
 - `attach(modelInstance)`: Attaches a model instance to the `ModelMix`.
@@ -404,6 +364,16 @@ new MixTogether(args = { config: {}, options: {} })
   - **config**: Specific configuration settings for Together AI, including the `apiKey`.
   - **options**: Default options for Together AI model instances.
 
+### MixGoogle Class Overview
+
+```javascript
+new MixGoogle(args = { config: {}, options: {} })
+```
+
+- **args**: Configuration object with `config` and `options` properties.
+  - **config**: Specific configuration settings for Google Gemini, including the `apiKey`.
+  - **options**: Default options for Google Gemini model instances.
+
 ## 🤝 Contributing
 
 Contributions are welcome! If you find any issues or have suggestions for improvement, please open an issue or submit a pull request on the [GitHub repository](https://github.com/clasen/ModelMix).

package/demo/custom.mjs

@@ -1,6 +1,6 @@
 import 'dotenv/config'
 
-import { ModelMix, MixCerebras, MixTogether } from '../index.js';
+import { ModelMix, MixCerebras } from '../index.js';
 
 const mmix = new ModelMix({
     options: {

package/demo/short.mjs

@@ -0,0 +1,28 @@
+import 'dotenv/config'
+
+import { ModelMix } from '../index.js';
+
+const setup = {
+    config: {
+        system: "You are ALF, if they ask your name, answer 'ALF'.",
+        debug: true
+    }
+};
+
+const result = await ModelMix.create(setup)
+    .sonnet37think()
+    .o4mini({ config: { temperature: 0 } })
+    .gpt41nano()
+    .grok3mini()
+    .gemini25flash()
+    .addText("What's your name?")
+    .message();
+
+console.log(result);
+
+const jsonResult = await ModelMix.create({ config: { debug: false } })
+    .sonnet37()
+    .addText("Name and capital of 3 South American countries.")
+    .json({ countries: [{ name: "", capital: "" }] });
+
+console.log(jsonResult);

package/demo/stream.mjs

@@ -52,17 +52,17 @@ mmix.attach(new MixOllama({
 
 
 await mmix.create('gpt-4o')
-    .addImage('./watson.jpg')
+    .addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg')
     .addText('describe')
     .stream((data) => { console.log(data.message); });
 
 await mmix.create('claude-3-haiku-20240307')
-    .addImage('./watson.jpg')
+    .addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg')
     .addText('describe')
     .stream((data) => { console.log(data.message); });
 
 await mmix.create('llava:latest')
-    .addImage('./watson.jpg')
+    .addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg')
     .addText('describe')
     .stream((data) => { console.log(data.message); });
 

package/index.js

@@ -6,14 +6,163 @@ const Bottleneck = require('bottleneck');
 const path = require('path');
 const generateJsonSchema = require('./schema');
 
+class ModelMixBuilder {
+    constructor(args = {}) {
+        this.models = []; // Array of { key: string, providerClass: class, options: {}, config: {} }
+        this.mix = new ModelMix(args);
+        this.handler = null;
+        this._messageHandlerMethods = [ // Methods to delegate after handler creation
+            'new', 'addText', 'addTextFromFile', 'setSystem', 'setSystemFromFile',
+            'addImage', 'addImageFromUrl', 'message', 'json', 'block', 'raw',
+            'stream', 'replace', 'replaceKeyFromFile'
+        ];
+    }
+
+    addModel(key, providerClass, { options = {}, config = {} } = {}) {
+        if (this.handler) {
+            throw new Error("Cannot add models after message generation has started.");
+        }
+
+        // Attach provider if not already attached
+        const providerInstance = new providerClass();
+        const mainPrefix = providerInstance.config.prefix[0];
+        if (!Object.values(this.mix.models).some(p => p.config.prefix.includes(mainPrefix))) {
+            this.mix.attach(providerInstance);
+        }
+
+        if (!key) {
+            throw new Error(`Model key is required when adding a model via ${providerClass.name}.`);
+        }
+        this.models.push({ key, providerClass, options, config });
+        return this;
+    }
+
+    _getHandler() {
+        if (!this.handler) {
+            if (!this.mix || this.models.length === 0) {
+                throw new Error("No models specified. Use methods like .gpt(), .sonnet() first.");
+            }
+
+            // Pass all model definitions. The create method will handle it appropriately
+            this.handler = this.mix.createByDef(this.models);
+
+            // Delegate chainable methods to the handler
+            this._messageHandlerMethods.forEach(methodName => {
+                if (typeof this.handler[methodName] === 'function') {
+                    this[methodName] = (...args) => {
+                        const result = this.handler[methodName](...args);
+                        // Return the handler instance for chainable methods, otherwise the result
+                        return result === this.handler ? this : result;
+                    };
+                }
+            });
+            // Special handling for async methods that return results
+            ['message', 'json', 'block', 'raw', 'stream'].forEach(asyncMethodName => {
+                if (typeof this.handler[asyncMethodName] === 'function') {
+                    this[asyncMethodName] = async (...args) => {
+                        return await this.handler[asyncMethodName](...args);
+                    };
+                }
+            });
+        }
+        return this.handler;
+    }
+
+    // --- Instance methods for adding models (primary or fallback) ---
+    // These will be mirrored by static methods on ModelMix
+    gpt41({ model = 'gpt-4.1', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    gpt41mini({ model = 'gpt-4.1-mini', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    gpt41nano({ model = 'gpt-4.1-nano', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    gpt4o({ model = 'gpt-4o', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    o4mini({ model = 'o4-mini', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    o3({ model = 'o3', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixOpenAI, { options, config });
+    }
+    sonnet37({ model = 'claude-3-7-sonnet-20250219', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixAnthropic, { options, config });
+    }
+    sonnet37think({ model = 'claude-3-7-sonnet-20250219', options = {
+        thinking: {
+            "type": "enabled",
+            "budget_tokens": 1024
+        },
+        temperature: 1
+    }, config = {} } = {}) {
+        return this.addModel(model, MixAnthropic, { options, config });
+    }
+    sonnet35({ model = 'claude-3-5-sonnet-20241022', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixAnthropic, { options, config });
+    }
+    haiku35({ model = 'claude-3-5-haiku-20241022', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixAnthropic, { options, config });
+    }
+    gemini25flash({ model = 'gemini-2.5-flash-preview-04-17', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGoogle, { options, config });
+    }
+    gemini25proExp({ model = 'gemini-2.5-pro-exp-03-25', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGoogle, { options, config });
+    }        
+    gemini25pro({ model = 'gemini-2.5-pro-preview-05-06', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGoogle, { options, config });
+    }    
+    sonar({ model = 'sonar-pro', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixPerplexity, { options, config });
+    }
+    qwen3({ model = 'Qwen/Qwen3-235B-A22B-fp8-tput', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixTogether, { options, config });
+    }
+    grok2({ model = 'grok-2-latest', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGrok, { options, config });
+    }
+    grok3({ model = 'grok-3-beta', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGrok, { options, config });
+    }
+    grok3mini({ model = 'grok-3-mini-beta', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixGrok, { options, config });
+    }
+    scout({ model = 'llama-4-scout-17b-16e-instruct', options = {}, config = {} } = {}) {
+        return this.addModel(model, MixCerebras, { options, config });
+    }
+
+    // --- Methods delegated to MessageHandler after creation ---
+    // Define stubs that will call _getHandler first
+
+    new() { this._getHandler(); return this.new(...arguments); }
+    addText() { this._getHandler(); return this.addText(...arguments); }
+    addTextFromFile() { this._getHandler(); return this.addTextFromFile(...arguments); }
+    setSystem() { this._getHandler(); return this.setSystem(...arguments); }
+    setSystemFromFile() { this._getHandler(); return this.setSystemFromFile(...arguments); }
+    addImage() { this._getHandler(); return this.addImage(...arguments); }
+    addImageFromUrl() { this._getHandler(); return this.addImageFromUrl(...arguments); }
+    replace() { this._getHandler(); return this.replace(...arguments); }
+    replaceKeyFromFile() { this._getHandler(); return this.replaceKeyFromFile(...arguments); }
+
+    // Async methods need await
+    async message() { this._getHandler(); return await this.message(...arguments); }
+    async json() { this._getHandler(); return await this.json(...arguments); }
+    async block() { this._getHandler(); return await this.block(...arguments); }
+    async raw() { this._getHandler(); return await this.raw(...arguments); }
+    async stream() { this._getHandler(); return await this.stream(...arguments); }
+}
+
 class ModelMix {
-    constructor(args = { options: {}, config: {} }) {
+    constructor({ options = {}, config = {} } = {}) {
         this.models = {};
         this.defaultOptions = {
-            max_tokens: 2000,
-            temperature: 1,
-            top_p: 1,
-            ...args.options
+            max_tokens: 5000,
+            temperature: 1, // 1 --> More creative, 0 --> More deterministic.
+            top_p: 1, // 100% --> The model considers all possible tokens.
+            ...options
         };
 
         // Standard Bottleneck configuration
@@ -28,7 +177,7 @@ class ModelMix {
             max_history: 1, // Default max history
             debug: false,
             bottleneck: defaultBottleneckConfig,
-            ...args.config
+            ...config
         }
 
         this.limiter = new Bottleneck(this.config.bottleneck);
@@ -47,16 +196,23 @@ class ModelMix {
         return this;
     }
 
-    create(modelKeys, args = { config: {}, options: {} }) {
-        // If modelKeys is a string, convert it to an array for backwards compatibility
-        const modelArray = Array.isArray(modelKeys) ? modelKeys : [modelKeys];
+    static create(args = {}) {
+        return new ModelMixBuilder(args);
+    }
 
-        if (modelArray.length === 0) {
-            throw new Error('No model keys provided');
+    createByDef(modelDefinitions, { config: explicitOverallConfig = {}, options: explicitOverallOptions = {} } = {}) {
+
+        // modelDefinitions is expected to be the array from ModelMixBuilder.models
+        // e.g., [{ key, providerClass, options, config }, ...]
+        const allModelsInfo = modelDefinitions;
+        const modelKeys = allModelsInfo.map(m => m.key);
+
+        if (modelKeys.length === 0) {
+            throw new Error('No model keys provided in modelDefinitions.');
         }
 
         // Verificar que todos los modelos estén disponibles
-        const unavailableModels = modelArray.filter(modelKey => {
+        const unavailableModels = modelKeys.filter(modelKey => {
             return !Object.values(this.models).some(entry =>
                 entry.config.prefix.some(p => modelKey.startsWith(p))
             );
@@ -66,27 +222,74 @@ class ModelMix {
             throw new Error(`The following models are not available: ${unavailableModels.join(', ')}`);
         }
 
-        // Una vez verificado que todos están disponibles, obtener el primer modelo
-        const modelKey = modelArray[0];
-        const modelEntry = Object.values(this.models).find(entry =>
-            entry.config.prefix.some(p => modelKey.startsWith(p))
+        // Una vez verificado que todos están disponibles, obtener el primer modelo (primary)
+        const primaryModelInfo = allModelsInfo[0];
+        const primaryModelKey = primaryModelInfo.key;
+        const primaryModelEntry = Object.values(this.models).find(entry =>
+            entry.config.prefix.some(p => primaryModelKey.startsWith(p))
         );
 
-        const options = {
-            ...this.defaultOptions,
-            ...modelEntry.options,
-            ...args.options,
-            model: modelKey
+        if (!primaryModelEntry) { // Should be caught by unavailableModels, but good for robustness
+            throw new Error(`Primary model provider for key ${primaryModelKey} not found or attached.`);
+        }
+
+        // Options/config for the MessageHandler instance (session-level)
+        // These are based on the primary model's specification.
+        const optionsHandler = {
+            ...this.defaultOptions,                 // ModelMix global defaults
+            ...(primaryModelEntry.options || {}),   // Primary provider class defaults
+            ...(primaryModelInfo.options || {}),    // Options from addModel for primary
+            ...explicitOverallOptions,              // Explicit options to .create() if any
+            model: primaryModelKey                  // Ensure primary model key is set
         };
 
-        const config = {
-            ...this.config,
-            ...modelEntry.config,
-            ...args.config
+        const configHandler = {
+            ...this.config,                         // ModelMix global config
+            ...(primaryModelEntry.config || {}),    // Primary provider class config
+            ...(primaryModelInfo.config || {}),     // Config from addModel for primary
+            ...explicitOverallConfig                // Explicit config to .create()
         };
 
-        // Pass remaining models array for fallback
-        return new MessageHandler(this, modelEntry, options, config, modelArray.slice(1));
+        // Pass the entire allModelsInfo array for fallback/iteration
+        return new MessageHandler(this, primaryModelEntry, optionsHandler, configHandler, allModelsInfo);
+    }
+
+    create(modelKeys = [], { config = {}, options = {} } = {}) {
+
+        // Backward compatibility for string model keys
+        if (!modelKeys || (Array.isArray(modelKeys) && modelKeys.length === 0)) {
+            return new ModelMixBuilder({ config: { ...this.config, ...config }, options: { ...this.defaultOptions, ...options } });
+        }
+
+        // If modelKeys is a string, convert it to an array for backward compatibility
+        const modelArray = Array.isArray(modelKeys) ? modelKeys : [modelKeys];
+
+        if (modelArray.length === 0) {
+            throw new Error('No model keys provided');
+        }
+
+        // Create model definitions based on string keys
+        const modelDefinitions = modelArray.map(key => {
+            // Find the provider for this model key
+            const providerEntry = Object.values(this.models).find(entry =>
+                entry.config.prefix.some(p => key.startsWith(p))
+            );
+
+            if (!providerEntry) {
+                throw new Error(`Model provider not found for key: ${key}`);
+            }
+
+            // Return a synthesized model definition with just the key and options/config from the create call
+            return {
+                key,
+                providerClass: null, // Not needed for our purpose
+                options,            // Use the options from create call for all models
+                config              // Use the config from create call for all models
+            };
+        });
+
+        // Pass to the new implementation
+        return this.createByDef(modelDefinitions, { config, options });
     }
 
     setSystem(text) {
@@ -100,10 +303,10 @@ class ModelMix {
         return this;
     }
 
-    readFile(filePath, options = { encoding: 'utf8' }) {
+    readFile(filePath, { encoding = 'utf8' } = {}) {
         try {
             const absolutePath = path.resolve(filePath);
-            return fs.readFileSync(absolutePath, options);
+            return fs.readFileSync(absolutePath, { encoding });
         } catch (error) {
             if (error.code === 'ENOENT') {
                 throw new Error(`File not found: ${filePath}`);
@@ -117,13 +320,13 @@ class ModelMix {
 }
 
 class MessageHandler {
-    constructor(mix, modelEntry, options, config, fallbackModels = []) {
+    constructor(mix, modelEntry, options, config, allModelsInfo = []) {
         this.mix = mix;
-        this.modelEntry = modelEntry;
-        this.options = options;
-        this.config = config;
+        this.modelEntry = modelEntry; // Primary model's provider instance
+        this.options = options;     // Session-level options, based on primary
+        this.config = config;       // Session-level config, based on primary
         this.messages = [];
-        this.fallbackModels = fallbackModels;
+        this.allModelsInfo = allModelsInfo; // Store the full info array [{ key, providerClass, options, config }, ...]
         this.imagesToProcess = [];
     }
 
@@ -142,9 +345,9 @@ class MessageHandler {
         return this;
     }
 
-    addTextFromFile(filePath, config = { role: "user" }) {
+    addTextFromFile(filePath, { role = "user" } = {}) {
         const content = this.mix.readFile(filePath);
-        this.addText(content, config);
+        this.addText(content, { role });
         return this;
     }
 
@@ -159,7 +362,7 @@ class MessageHandler {
         return this;
     }
 
-    addImage(filePath, config = { role: "user" }) {
+    addImage(filePath, { role = "user" } = {}) {
         const imageBuffer = this.mix.readFile(filePath, { encoding: null });
         const mimeType = mime.lookup(filePath);
 
@@ -170,7 +373,7 @@ class MessageHandler {
         const data = imageBuffer.toString('base64');
 
         const imageMessage = {
-            ...config,
+            ...{ role },
             content: [
                 {
                     type: "image",
@@ -230,23 +433,29 @@ class MessageHandler {
 
     async message() {
         this.options.stream = false;
-        const response = await this.execute();
-        return response.message;
+        let raw = await this.execute();
+        if (!raw.message && raw.response?.content?.[1]?.text) {
+            return raw.response.content[1].text;
+        }
+
+        return raw.message;
     }
 
-    async json(schemaExample = null, schemaDescription = {}, { type = 'json_object', addExample = false } = {}) {
+    async json(schemaExample = null, schemaDescription = {}, { type = 'json_object', addExample = false, addSchema = true } = {}) {
         this.options.response_format = { type };
         if (schemaExample) {
-            const schema = generateJsonSchema(schemaExample, schemaDescription);
-            this.config.systemExtra = "\nOutput JSON Schema: \n```\n" + JSON.stringify(schema) + "\n```";
+
+            if (addSchema) {
+                const schema = generateJsonSchema(schemaExample, schemaDescription);
+                this.config.systemExtra = "\nOutput JSON Schema: \n```\n" + JSON.stringify(schema) + "\n```";
+            }
 
             if (addExample) {
-                this.config.systemExtra += "\nOutput Example: \n```\n" + JSON.stringify(schemaExample) + "\n```";
+                this.config.systemExtra += "\nOutput JSON Example: \n```\n" + JSON.stringify(schemaExample) + "\n```";
             }
         }
         const response = await this.message();
         this.config.systemExtra = "";
-        console.log(response);
         return JSON.parse(this._extractBlock(response));
     }
 
@@ -335,70 +544,143 @@ class MessageHandler {
 
     async execute() {
         return this.mix.limiter.schedule(async () => {
-            try {
-                await this.prepareMessages();
+            await this.prepareMessages(); // Prepare messages once, outside the loop
 
-                if (this.messages.length === 0) {
-                    throw new Error("No user messages have been added. Use addText(prompt), addTextFromFile(filePath), addImage(filePath), or addImageFromUrl(url) to add a prompt.");
+            if (this.messages.length === 0) {
+                throw new Error("No user messages have been added. Use addText(prompt), addTextFromFile(filePath), addImage(filePath), or addImageFromUrl(url) to add a prompt.");
+            }
+
+            let lastError = null;
+            const modelIterationList = this.allModelsInfo; // Use the full info for iteration
+
+            // Iterate through the models defined in the handler's list
+            for (let i = 0; i < modelIterationList.length; i++) {
+                const currentModelDetail = modelIterationList[i];
+                const currentModelKey = currentModelDetail.key;
+                const currentModelBuilderOptions = currentModelDetail.options || {};
+                const currentModelBuilderConfig = currentModelDetail.config || {};
+
+                // Find the corresponding model provider instance in the ModelMix instance
+                const currentModelProviderInstance = Object.values(this.mix.models).find(entry =>
+                    entry.config.prefix.some(p => currentModelKey.startsWith(p))
+                );
+
+                if (!currentModelProviderInstance) {
+                    log.warn(`Model provider not found or attached for key: ${currentModelKey}. Skipping.`);
+                    if (!lastError) {
+                        lastError = new Error(`Model provider not found for key: ${currentModelKey}`);
+                    }
+                    continue; // Try the next model
                 }
 
+                // Construct effective options and config for THIS attempt
+                const attemptOptions = {
+                    ...this.mix.defaultOptions,                            // 1. ModelMix global defaults
+                    ...(currentModelProviderInstance.options || {}),      // 2. Provider class defaults for current model
+                    ...this.options,                                       // 3. MessageHandler current general options (from primary + handler changes)
+                    ...currentModelBuilderOptions,                         // 4. Specific options from addModel for THIS model
+                    model: currentModelKey                                 // 5. Crucial: set current model key
+                };
+
+                const attemptConfig = {
+                    ...this.mix.config,                                    // 1. ModelMix global config
+                    ...(currentModelProviderInstance.config || {}),       // 2. Provider class config for current model
+                    ...this.config,                                        // 3. MessageHandler current general config
+                    ...currentModelBuilderConfig                           // 4. Specific config from addModel for THIS model
+                };
+
+                // Determine the effective debug flag for this attempt (for logging and API call context)
+                // Precedence: model-specific builder config -> handler config -> mix config
+                const effectiveDebugForAttempt = attemptConfig.hasOwnProperty('debug') ? attemptConfig.debug :
+                    this.config.hasOwnProperty('debug') ? this.config.debug :
+                        this.mix.config.debug;
+
+                // Update attemptConfig with the finally resolved debug flag for the API call
+                const apiCallConfig = { ...attemptConfig, debug: effectiveDebugForAttempt };
+
+
+                if (effectiveDebugForAttempt) {
+                    const isPrimary = i === 0;
+                    log.debug(`Attempt #${i + 1}: Using model ${currentModelKey}` + (isPrimary ? ' (Primary)' : ' (Fallback)'));
+                    log.debug("Effective attemptOptions for " + currentModelKey + ":");
+                    log.inspect(attemptOptions);
+                    log.debug("Effective apiCallConfig for " + currentModelKey + ":");
+                    log.inspect(apiCallConfig);
+                }
+
+
+                // Apply model-specific adjustments to a copy of options for this attempt
+                let finalAttemptOptions = { ...attemptOptions };
+                if (currentModelProviderInstance instanceof MixOpenAI && finalAttemptOptions.model?.startsWith('o')) {
+                    delete finalAttemptOptions.max_tokens;
+                    delete finalAttemptOptions.temperature;
+                }
+                if (currentModelProviderInstance instanceof MixAnthropic) {
+                    if (finalAttemptOptions.thinking) {
+                        delete finalAttemptOptions.top_p;
+                        // if (finalAttemptOptions.temperature < 1) {
+                        //     finalAttemptOptions.temperature = 1;
+                        // }
+                    }
+                    delete finalAttemptOptions.response_format; // Anthropic doesn't use this top-level option
+                }
+                // ... add other potential model-specific option adjustments here ...
+
                 try {
-                    const result = await this.modelEntry.create({ options: this.options, config: this.config });
-                    this.messages.push({ role: "assistant", content: result.message });
-                    return result;
-                } catch (error) {
-                    // If there are fallback models available, try the next one
-                    if (this.fallbackModels.length > 0) {
-                        const nextModelKey = this.fallbackModels[0];
-                        log.warn(`Model ${this.options.model} failed, trying fallback model ${nextModelKey}...`);
-                        error.details && log.warn(error.details);
-
-                        // Create a completely new handler with the fallback model
-                        const nextHandler = this.mix.create(
-                            [nextModelKey, ...this.fallbackModels.slice(1)],
-                            {
-                                options: {
-                                    // Keep only generic options, not model-specific ones
-                                    max_tokens: this.options.max_tokens,
-                                    temperature: this.options.temperature,
-                                    top_p: this.options.top_p,
-                                    stream: this.options.stream
-                                }
-                            }
-                        );
+                    // Attach the stream callback to the *current* model entry for this attempt
+                    // this.modelEntry is the primary model's provider instance where streamCallback was stored by MessageHandler.stream()
+                    if (finalAttemptOptions.stream && this.modelEntry && this.modelEntry.streamCallback) {
+                        currentModelProviderInstance.streamCallback = this.modelEntry.streamCallback;
+                    }
 
-                        // Assign all messages directly
-                        nextHandler.messages = [...this.messages];
+                    // Pass the adjusted options/config for this specific attempt
+                    const result = await currentModelProviderInstance.create({ options: finalAttemptOptions, config: apiCallConfig });
 
-                        // Keep same system and replacements
-                        nextHandler.setSystem(this.config.system);
-                        nextHandler.config.systemExtra = this.config.systemExtra;
-                        if (this.config.replace) {
-                            nextHandler.replace(this.config.replace);
-                        }
+                    // Add successful response to history *before* returning
+                    let messageContentToAdd = result.message;
+                    if (currentModelProviderInstance instanceof MixAnthropic && result.response?.content?.[0]?.text) {
+                        messageContentToAdd = result.response.content[0].text;
+                    } else if (currentModelProviderInstance instanceof MixOllama && result.response?.message?.content) {
+                        messageContentToAdd = result.response.message.content;
+                    } // Add more cases if other providers have different structures
 
-                        await nextHandler.prepareMessages();
+                    this.messages.push({ role: "assistant", content: messageContentToAdd });
 
-                        const result = await nextHandler.modelEntry.create({
-                            options: nextHandler.options,
-                            config: nextHandler.config
-                        });
-                        nextHandler.messages.push({ role: "assistant", content: result.message });
-                        return result;
+                    if (effectiveDebugForAttempt) {
+                        log.debug(`Request successful with model: ${currentModelKey}`);
+                        log.inspect(result.response);
+                    }
+                    return result; // Success!
+                } catch (error) {
+                    lastError = error; // Store the most recent error
+                    log.warn(`Model ${currentModelKey} failed (Attempt #${i + 1}/${modelIterationList.length}).`);
+                    if (error.message) log.warn(`Error: ${error.message}`);
+                    if (error.statusCode) log.warn(`Status Code: ${error.statusCode}`);
+                    if (error.details) log.warn(`Details: ${JSON.stringify(error.details)}`);
+
+                    // Check if this is the last model in the list
+                    if (i === modelIterationList.length - 1) {
+                        log.error(`All ${modelIterationList.length} model(s) failed. Throwing last error from ${currentModelKey}.`);
+                        throw lastError; // Re-throw the last encountered error
+                    } else {
+                        const nextModelKey = modelIterationList[i + 1].key;
+                        log.info(`-> Proceeding to next model: ${nextModelKey}`);
                     }
-                    throw error;
                 }
-            } catch (error) {
-                throw error;
             }
+
+            // This point should theoretically not be reached if there's at least one model key
+            // and the loop either returns a result or throws an error.
+            log.error("Fallback logic completed without success or throwing the final error.");
+            throw lastError || new Error("Failed to get response from any model, and no specific error was caught.");
         });
     }
 }
 class MixCustom {
-    constructor(args = { config: {}, options: {}, headers: {} }) {
-        this.config = this.getDefaultConfig(args.config);
-        this.options = this.getDefaultOptions(args.options);
-        this.headers = this.getDefaultHeaders(args.headers);
+    constructor({ config = {}, options = {}, headers = {} } = {}) {
+        this.config = this.getDefaultConfig(config);
+        this.options = this.getDefaultOptions(options);
+        this.headers = this.getDefaultHeaders(headers);
         this.streamCallback = null; // Definimos streamCallback aquí
     }
 
@@ -426,31 +708,31 @@ class MixCustom {
         };
     }
 
-    async create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         try {
-            if (args.config.debug) {
+            if (config.debug) {
                 log.debug("config");
-                log.info(args.config);
+                log.info(config);
                 log.debug("options");
-                log.inspect(args.options);
+                log.inspect(options);
             }
 
-            if (args.options.stream) {
-                return this.processStream(await axios.post(this.config.url, args.options, {
+            if (options.stream) {
+                return this.processStream(await axios.post(this.config.url, options, {
                     headers: this.headers,
                     responseType: 'stream'
                 }));
             } else {
-                return this.processResponse(await axios.post(this.config.url, args.options, {
+                return this.processResponse(await axios.post(this.config.url, options, {
                     headers: this.headers
                 }));
             }
         } catch (error) {
-            throw this.handleError(error, args);
+            throw this.handleError(error, { config, options });
         }
     }
 
-    handleError(error, args) {
+    handleError(error, { config, options }) {
         let errorMessage = 'An error occurred in MixCustom';
         let statusCode = null;
         let errorDetails = null;
@@ -466,8 +748,8 @@ class MixCustom {
             statusCode,
             details: errorDetails,
             stack: error.stack,
-            config: args.config,
-            options: args.options
+            config: config,
+            options: options
         };
 
         return formattedError;
@@ -530,21 +812,21 @@ class MixOpenAI extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         if (!this.config.apiKey) {
             throw new Error('OpenAI API key not found. Please provide it in config or set OPENAI_API_KEY environment variable.');
         }
 
         // Remove max_tokens and temperature for o1/o3 models
-        if (args.options.model?.startsWith('o')) {
-            delete args.options.max_tokens;
-            delete args.options.temperature;
+        if (options.model?.startsWith('o')) {
+            delete options.max_tokens;
+            delete options.temperature;
         }
 
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        args.options.messages = MixOpenAI.convertMessages(args.options.messages);
-        return super.create(args);
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        options.messages = MixOpenAI.convertMessages(options.messages);
+        return super.create({ config, options });
     }
 
     static convertMessages(messages) {
@@ -578,15 +860,20 @@ class MixAnthropic extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         if (!this.config.apiKey) {
             throw new Error('Anthropic API key not found. Please provide it in config or set ANTHROPIC_API_KEY environment variable.');
         }
 
-        delete args.options.response_format;
+        // Remove top_p for thinking
+        if (options.thinking) {
+            delete options.top_p;
+        }
+
+        delete options.response_format;
 
-        args.options.system = args.config.system + args.config.systemExtra;
-        return super.create(args);
+        options.system = config.system + config.systemExtra;
+        return super.create({ config, options });
     }
 
     getDefaultHeaders(customHeaders) {
@@ -611,20 +898,20 @@ class MixPerplexity extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.perplexity.ai/chat/completions',
-            prefix: ['llama-3', 'mixtral'],
+            prefix: ['sonar'],
             apiKey: process.env.PPLX_API_KEY,
             ...customConfig
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         if (!this.config.apiKey) {
             throw new Error('Perplexity API key not found. Please provide it in config or set PPLX_API_KEY environment variable.');
         }
 
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        return super.create(args);
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        return super.create({ config, options });
     }
 }
 
@@ -648,12 +935,12 @@ class MixOllama extends MixCustom {
         return '';
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
 
-        args.options.messages = MixOllama.convertMessages(args.options.messages);
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        return super.create(args);
+        options.messages = MixOllama.convertMessages(options.messages);
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        return super.create({ config, options });
     }
 
     processResponse(response) {
@@ -701,11 +988,11 @@ class MixLMStudio extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        args.options.messages = MixOpenAI.convertMessages(args.options.messages);
-        return super.create(args);
+    async create({ config = {}, options = {} } = {}) {
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        options.messages = MixOpenAI.convertMessages(options.messages);
+        return super.create({ config, options });
     }
 }
 
@@ -719,15 +1006,15 @@ class MixGroq extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         if (!this.config.apiKey) {
             throw new Error('Groq API key not found. Please provide it in config or set GROQ_API_KEY environment variable.');
         }
 
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        args.options.messages = MixOpenAI.convertMessages(args.options.messages);
-        return super.create(args);
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        options.messages = MixOpenAI.convertMessages(options.messages);
+        return super.create({ config, options });
     }
 }
 
@@ -735,7 +1022,7 @@ class MixTogether extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.together.xyz/v1/chat/completions',
-            prefix: ["meta-llama", "google", "NousResearch", "deepseek-ai"],
+            prefix: ["meta-llama", "google", "NousResearch", "deepseek-ai", "Qwen"],
             apiKey: process.env.TOGETHER_API_KEY,
             ...customConfig
         });
@@ -757,16 +1044,16 @@ class MixTogether extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
         if (!this.config.apiKey) {
             throw new Error('Together API key not found. Please provide it in config or set TOGETHER_API_KEY environment variable.');
         }
 
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        args.options.messages = MixTogether.convertMessages(args.options.messages);
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        options.messages = MixTogether.convertMessages(options.messages);
 
-        return super.create(args);
+        return super.create({ config, options });
     }
 }
 
@@ -780,12 +1067,126 @@ class MixCerebras extends MixCustom {
         });
     }
 
-    create(args = { config: {}, options: {} }) {
-        const content = args.config.system + args.config.systemExtra;
-        args.options.messages = [{ role: 'system', content }, ...args.options.messages || []];
-        args.options.messages = MixTogether.convertMessages(args.options.messages);
-        return super.create(args);
+    async create({ config = {}, options = {} } = {}) {
+        const content = config.system + config.systemExtra;
+        options.messages = [{ role: 'system', content }, ...options.messages || []];
+        options.messages = MixTogether.convertMessages(options.messages);
+        return super.create({ config, options });
+    }
+}
+
+class MixGoogle extends MixCustom {
+    getDefaultConfig(customConfig) {
+        return super.getDefaultConfig({
+            url: 'https://generativelanguage.googleapis.com/v1beta/models',
+            prefix: ['gemini'],
+            apiKey: process.env.GOOGLE_API_KEY,
+            ...customConfig
+        });
+    }
+
+    getDefaultHeaders(customHeaders) {
+        // Remove the authorization header as we'll use the API key as a query parameter
+        return {
+            'Content-Type': 'application/json',
+            ...customHeaders
+        };
+    }
+
+    getDefaultOptions(customOptions) {
+        return {
+            generationConfig: {
+                responseMimeType: "text/plain"
+            },
+            ...customOptions
+        };
+    }
+
+    static convertMessages(messages) {
+        return messages.map(message => {
+            const parts = [];
+            
+            if (message.content instanceof Array) {
+                message.content.forEach(content => {
+                    if (content.type === 'text') {
+                        parts.push({ text: content.text });
+                    } else if (content.type === 'image') {
+                        parts.push({
+                            inline_data: {
+                                mime_type: content.source.media_type,
+                                data: content.source.data
+                            }
+                        });
+                    }
+                });
+            } else {
+                parts.push({ text: message.content });
+            }
+
+            return {
+                role: message.role === 'assistant' ? 'model' : 'user',
+                parts
+            };
+        });
+    }
+
+    async create({ config = {}, options = {} } = {}) {
+        if (!this.config.apiKey) {
+            throw new Error('Google API key not found. Please provide it in config or set GOOGLE_API_KEY environment variable.');
+        }
+
+        const modelId = options.model || 'gemini-2.5-flash-preview-04-17';
+        const generateContentApi = options.stream ? 'streamGenerateContent' : 'generateContent';
+        
+        // Construct the full URL with model ID, API endpoint, and API key
+        const fullUrl = `${this.config.url}/${modelId}:${generateContentApi}?key=${this.config.apiKey}`;
+
+        // Convert messages to Gemini format
+        const contents = MixGoogle.convertMessages(options.messages);
+        
+        // Add system message if present
+        if (config.system || config.systemExtra) {
+            contents.unshift({
+                role: 'user',
+                parts: [{ text: (config.system || '') + (config.systemExtra || '') }]
+            });
+        }
+
+        // Prepare the request payload
+        const payload = {
+            contents,
+            generationConfig: options.generationConfig || this.getDefaultOptions().generationConfig
+        };
+
+        try {
+            if (options.stream) {
+                throw new Error('Stream is not supported for Gemini');
+            } else {
+                return this.processResponse(await axios.post(fullUrl, payload, {
+                    headers: this.headers
+                }));
+            }
+        } catch (error) {
+            throw this.handleError(error, { config, options });
+        }
+    }
+
+    extractDelta(data) {
+        try {
+            const parsed = JSON.parse(data);
+            if (parsed.candidates?.[0]?.content?.parts?.[0]?.text) {
+                return parsed.candidates[0].content.parts[0].text;
+            }
+        } catch (e) {
+            // If parsing fails, return empty string
+        }
+        return '';
+    }
+
+    processResponse(response) {
+        const content = response.data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+        return { response: response.data, message: content };
     }
 }
 
-module.exports = { MixCustom, ModelMix, MixAnthropic, MixOpenAI, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras };
+module.exports = { MixCustom, ModelMix, MixAnthropic, MixOpenAI, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "3.1.6",
+  "version": "3.2.2",
   "description": "🧬 ModelMix - Unified API for Diverse AI LLM.",
   "main": "index.js",
   "repository": {
@@ -16,7 +16,6 @@
     "agent",
     "perplexity",
     "grok",
-    "sonnet-3",
     "gpt",
     "claude",
     "llama",
@@ -24,6 +23,7 @@
     "chat",
     "multimodal",
     "groq",
+    "gemini",
     "ollama",
     "lmstudio",
     "together",
@@ -31,6 +31,7 @@
     "deepseek",
     "o4",
     "4.1",
+    "qwen",
     "nousresearch",
     "reasoning",
     "bottleneck",