modelmix 3.1.8 → 3.3.2

package/index.js

@@ -7,13 +7,14 @@ const path = require('path');
 const generateJsonSchema = require('./schema');
 
 class ModelMix {
-    constructor(args = { options: {}, config: {} }) {
-        this.models = {};
-        this.defaultOptions = {
-            max_tokens: 2000,
-            temperature: 1,
-            top_p: 1,
-            ...args.options
+    constructor({ options = {}, config = {} } = {}) {
+        this.models = [];
+        this.messages = [];
+        this.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,10 +29,11 @@ class ModelMix {
             max_history: 1, // Default max history
             debug: false,
             bottleneck: defaultBottleneckConfig,
-            ...args.config
+            ...config
         }
 
         this.limiter = new Bottleneck(this.config.bottleneck);
+
     }
 
     replace(keyValues) {
@@ -39,112 +41,132 @@ class ModelMix {
         return this;
     }
 
-    attach(...modelInstances) {
-        for (const modelInstance of modelInstances) {
-            const key = modelInstance.config.prefix.join("_");
-            this.models[key] = modelInstance;
-        }
-        return this;
+    static new({ options = {}, config = {} } = {}) {
+        return new ModelMix({ options, config });
     }
 
-    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];
-
-        if (modelArray.length === 0) {
-            throw new Error('No model keys provided');
-        }
+    new() {
+        return new ModelMix({ options: this.options, config: this.config });
+    }
 
-        // Verificar que todos los modelos estén disponibles
-        const unavailableModels = modelArray.filter(modelKey => {
-            return !Object.values(this.models).some(entry =>
-                entry.config.prefix.some(p => modelKey.startsWith(p))
-            );
-        });
+    attach(key, provider) {
 
-        if (unavailableModels.length > 0) {
-            throw new Error(`The following models are not available: ${unavailableModels.join(', ')}`);
+        if (this.models.some(model => model.key === key)) {
+            return this;
         }
 
-        // 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))
-        );
-
-        const options = {
-            ...this.defaultOptions,
-            ...modelEntry.options,
-            ...args.options,
-            model: modelKey
-        };
-
-        const config = {
-            ...this.config,
-            ...modelEntry.config,
-            ...args.config
-        };
+        if (this.messages.length > 0) {
+            throw new Error("Cannot add models after message generation has started.");
+        }
 
-        // Pass remaining models array for fallback
-        return new MessageHandler(this, modelEntry, options, config, modelArray.slice(1));
+        this.models.push({ key, provider });
+        return this;
     }
 
-    setSystem(text) {
-        this.config.system = text;
-        return this;
+    // --- Model addition methods ---
+    gpt41({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-4.1', new MixOpenAI({ options, config }));
+    }
+    gpt41mini({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-4.1-mini', new MixOpenAI({ options, config }));
+    }
+    gpt41nano({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-4.1-nano', new MixOpenAI({ options, config }));
+    }
+    gpt4o({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-4o', new MixOpenAI({ options, config }));
+    }
+    o4mini({ options = {}, config = {} } = {}) {
+        return this.attach('o4-mini', new MixOpenAI({ options, config }));
+    }
+    o3({ options = {}, config = {} } = {}) {
+        return this.attach('o3', new MixOpenAI({ options, config }));
+    }
+    gpt45({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-4.5-preview', new MixOpenAI({ options, config }));
+    }
+    sonnet37({ options = {}, config = {} } = {}) {
+        return this.attach('claude-3-7-sonnet-20250219', new MixAnthropic({ options, config }));
+    }
+    sonnet37think({ options = {
+        thinking: {
+            "type": "enabled",
+            "budget_tokens": 1024
+        },
+        temperature: 1
+    }, config = {} } = {}) {
+        return this.attach('claude-3-7-sonnet-20250219', new MixAnthropic({ options, config }));
+    }
+    sonnet35({ options = {}, config = {} } = {}) {
+        return this.attach('claude-3-5-sonnet-20241022', new MixAnthropic({ options, config }));
+    }
+    haiku35({ options = {}, config = {} } = {}) {
+        return this.attach('claude-3-5-haiku-20241022', new MixAnthropic({ options, config }));
+    }
+    gemini25flash({ options = {}, config = {} } = {}) {
+        return this.attach('gemini-2.5-flash-preview-04-17', new MixGoogle({ options, config }));
+    }
+    gemini25proExp({ options = {}, config = {} } = {}) {
+        return this.attach('gemini-2.5-pro-exp-03-25', new MixGoogle({ options, config }));
+    }
+    gemini25pro({ options = {}, config = {} } = {}) {
+        return this.attach('gemini-2.5-pro-preview-05-06', new MixGoogle({ options, config }));
+    }
+    sonarPro({ options = {}, config = {} } = {}) {
+        return this.attach('sonar-pro', new MixPerplexity({ options, config }));
+    }
+    sonar({ options = {}, config = {} } = {}) {
+        return this.attach('sonar', new MixPerplexity({ options, config }));
     }
 
-    setSystemFromFile(filePath) {
-        const content = this.readFile(filePath);
-        this.setSystem(content);
-        return this;
+    grok2({ options = {}, config = {} } = {}) {
+        return this.attach('grok-2-latest', new MixGrok({ options, config }));
+    }
+    grok3({ options = {}, config = {} } = {}) {
+        return this.attach('grok-3-beta', new MixGrok({ options, config }));
+    }
+    grok3mini({ options = {}, config = {} } = {}) {
+        return this.attach('grok-3-mini-beta', new MixGrok({ options, config }));
     }
 
-    readFile(filePath, options = { encoding: 'utf8' }) {
-        try {
-            const absolutePath = path.resolve(filePath);
-            return fs.readFileSync(absolutePath, options);
-        } catch (error) {
-            if (error.code === 'ENOENT') {
-                throw new Error(`File not found: ${filePath}`);
-            } else if (error.code === 'EACCES') {
-                throw new Error(`Permission denied: ${filePath}`);
-            } else {
-                throw new Error(`Error reading file ${filePath}: ${error.message}`);
-            }
-        }
+    qwen3({ options = {}, config = {}, mix = { groq: true, together: false } } = {}) {
+        if (mix.groq) this.attach('qwen-qwq-32b', new MixGroq({ options, config }));
+        if (mix.together) this.attach('Qwen/Qwen3-235B-A22B-fp8-tput', new MixTogether({ options, config }));
+        return this;
     }
-}
 
-class MessageHandler {
-    constructor(mix, modelEntry, options, config, fallbackModels = []) {
-        this.mix = mix;
-        this.modelEntry = modelEntry;
-        this.options = options;
-        this.config = config;
-        this.messages = [];
-        this.fallbackModels = fallbackModels;
-        this.imagesToProcess = [];
+    scout({ options = {}, config = {}, mix = { groq: true, together: false, cerebras: false } } = {}) {
+        if (mix.groq) this.attach('meta-llama/llama-4-scout-17b-16e-instruct', new MixGroq({ options, config }));
+        if (mix.together) this.attach('meta-llama/Llama-4-Scout-17B-16E-Instruct', new MixTogether({ options, config }));
+        if (mix.cerebras) this.attach('llama-4-scout-17b-16e-instruct', new MixCerebras({ options, config }));
+        return this;
+    }  
+    maverick({ options = {}, config = {}, mix = { groq: true, together: false } } = {}) {
+        if (mix.groq) this.attach('meta-llama/llama-4-maverick-17b-128e-instruct', new MixGroq({ options, config }));
+        if (mix.together) this.attach('meta-llama/Llama-4-Maverick-17B-128E-Instruct-FP8', new MixTogether({ options, config }));
+        return this;
     }
 
-    new() {
-        this.messages = [];
+    deepseekR1({ options = {}, config = {}, mix = { groq: true, together: false, cerebras: false } } = {}) {
+        if (mix.groq) this.attach('deepseek-r1-distill-llama-70b', new MixGroq({ options, config }));
+        if (mix.together) this.attach('deepseek-ai/DeepSeek-R1', new MixTogether({ options, config }));
+        if (mix.cerebras) this.attach('deepseek-r1-distill-llama-70b', new MixCerebras({ options, config }));
         return this;
     }
 
-    addText(text, config = { role: "user" }) {
+    addText(text, { role = "user" } = {}) {
         const content = [{
             type: "text",
             text
         }];
 
-        this.messages.push({ ...config, content });
+        this.messages.push({ role, content });
         return this;
     }
 
-    addTextFromFile(filePath, config = { role: "user" }) {
-        const content = this.mix.readFile(filePath);
-        this.addText(content, config);
+    addTextFromFile(filePath, { role = "user" } = {}) {
+        const content = this.readFile(filePath);
+        this.addText(content, { role });
         return this;
     }
 
@@ -154,13 +176,13 @@ class MessageHandler {
     }
 
     setSystemFromFile(filePath) {
-        const content = this.mix.readFile(filePath);
+        const content = this.readFile(filePath);
         this.setSystem(content);
         return this;
     }
 
-    addImage(filePath, config = { role: "user" }) {
-        const imageBuffer = this.mix.readFile(filePath, { encoding: null });
+    addImage(filePath, { role = "user" } = {}) {
+        const imageBuffer = this.readFile(filePath, { encoding: null });
         const mimeType = mime.lookup(filePath);
 
         if (!mimeType || !mimeType.startsWith('image/')) {
@@ -170,7 +192,7 @@ class MessageHandler {
         const data = imageBuffer.toString('base64');
 
         const imageMessage = {
-            ...config,
+            ...{ role },
             content: [
                 {
                     type: "image",
@@ -184,16 +206,20 @@ class MessageHandler {
         };
 
         this.messages.push(imageMessage);
-
         return this;
     }
 
     addImageFromUrl(url, config = { role: "user" }) {
+        if (!this.imagesToProcess) {
+            this.imagesToProcess = [];
+        }
         this.imagesToProcess.push({ url, config });
         return this;
     }
 
     async processImageUrls() {
+        if (!this.imagesToProcess) return;
+
         const imageContents = await Promise.all(
             this.imagesToProcess.map(async (image) => {
                 try {
@@ -202,7 +228,7 @@ class MessageHandler {
                     const mimeType = response.headers['content-type'];
                     return { base64, mimeType, config: image.config };
                 } catch (error) {
-                    console.error(`Error descargando imagen desde ${image.url}:`, error);
+                    console.error(`Error downloading image from ${image.url}:`, error);
                     return null;
                 }
             })
@@ -230,18 +256,21 @@ class MessageHandler {
 
     async message() {
         this.options.stream = false;
-        const response = await this.execute();
-        return response.message;
+        let raw = await this.execute();
+        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```";
+            this.config.schema = generateJsonSchema(schemaExample, schemaDescription);
 
+            if (addSchema) {
+                this.config.systemExtra = "\nOutput JSON Schema: \n```\n" + JSON.stringify(this.config.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();
@@ -270,22 +299,18 @@ class MessageHandler {
 
     async stream(callback) {
         this.options.stream = true;
-        this.modelEntry.streamCallback = callback;
+        this.streamCallback = callback;
         return this.execute();
     }
 
-    replace(keyValues) {
-        this.config.replace = { ...this.config.replace, ...keyValues };
-        return this;
-    }
-
     replaceKeyFromFile(key, filePath) {
-        const content = this.mix.readFile(filePath);
+        const content = this.readFile(filePath);
         this.replace({ [key]: this.template(content, this.config.replace) });
         return this;
     }
 
     template(input, replace) {
+        if (!replace) return input;
         for (const k in replace) {
             input = input.split(/([¿?¡!,"';:\(\)\.\s])/).map(x => x === k ? replace[k] : x).join("");
         }
@@ -309,13 +334,13 @@ class MessageHandler {
     applyTemplate() {
         if (!this.config.replace) return;
 
-        this.config.system = this.template(this.config.system, this.config.replace)
+        this.config.system = this.template(this.config.system, this.config.replace);
 
         this.messages = this.messages.map(message => {
             if (message.content instanceof Array) {
                 message.content = message.content.map(content => {
                     if (content.type === 'text') {
-                        content.text = this.template(content.text, this.config.replace)
+                        content.text = this.template(content.text, this.config.replace);
                     }
                     return content;
                 });
@@ -332,72 +357,101 @@ class MessageHandler {
         this.options.messages = this.messages;
     }
 
+    readFile(filePath, { encoding = 'utf8' } = {}) {
+        try {
+            const absolutePath = path.resolve(filePath);
+            return fs.readFileSync(absolutePath, { encoding });
+        } catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`File not found: ${filePath}`);
+            } else if (error.code === 'EACCES') {
+                throw new Error(`Permission denied: ${filePath}`);
+            } else {
+                throw new Error(`Error reading file ${filePath}: ${error.message}`);
+            }
+        }
+    }
+
     async execute() {
-        return this.mix.limiter.schedule(async () => {
-            try {
-                await this.prepareMessages();
+        if (!this.models || this.models.length === 0) {
+            throw new Error("No models specified. Use methods like .gpt(), .sonnet() first.");
+        }
+
+        return this.limiter.schedule(async () => {
+            await this.prepareMessages();
+
+            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;
 
-                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.");
+            for (let i = 0; i < this.models.length; i++) {
+
+                const currentModel = this.models[i];
+                const currentModelKey = currentModel.key;
+                const providerInstance = currentModel.provider;
+
+                let options = {
+                    ...this.options,
+                    ...providerInstance.options,
+                    model: currentModelKey
+                };
+
+                const config = {
+                    ...this.config,
+                    ...providerInstance.config,
+                };
+
+                if (config.debug) {
+                    const isPrimary = i === 0;
+                    log.debug(`[${currentModelKey}] Attempt #${i + 1}` + (isPrimary ? ' (Primary)' : ' (Fallback)'));
                 }
 
                 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
-                                }
-                            }
-                        );
+                    if (options.stream && this.streamCallback) {
+                        providerInstance.streamCallback = this.streamCallback;
+                    }
 
-                        // Assign all messages directly
-                        nextHandler.messages = [...this.messages];
+                    const result = await providerInstance.create({ options, config });
 
-                        // 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);
-                        }
+                    this.messages.push({ role: "assistant", content: result.message });
+
+                    if (config.debug) {
+                        log.debug(`Request successful with model: ${currentModelKey}`);
+                        log.inspect(result.response);
+                    }
 
-                        await nextHandler.prepareMessages();
+                    return result;
 
-                        const result = await nextHandler.modelEntry.create({
-                            options: nextHandler.options,
-                            config: nextHandler.config
-                        });
-                        nextHandler.messages.push({ role: "assistant", content: result.message });
-                        return result;
+                } catch (error) {
+                    lastError = error;
+                    log.warn(`Model ${currentModelKey} failed (Attempt #${i + 1}/${this.models.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)}`);
+
+                    if (i === this.models.length - 1) {
+                        log.error(`All ${this.models.length} model(s) failed. Throwing last error from ${currentModelKey}.`);
+                        throw lastError;
+                    } else {
+                        const nextModelKey = this.models[i + 1].key;
+                        log.info(`-> Proceeding to next model: ${nextModelKey}`);
                     }
-                    throw error;
                 }
-            } catch (error) {
-                throw 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í
     }
 
@@ -411,7 +465,6 @@ class MixCustom {
         return {
             url: '',
             apiKey: '',
-            prefix: [],
             ...customConfig
         };
     }
@@ -425,31 +478,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;
@@ -465,8 +518,8 @@ class MixCustom {
             statusCode,
             details: errorDetails,
             stack: error.stack,
-            config: args.config,
-            options: args.options
+            config: config,
+            options: options
         };
 
         return formattedError;
@@ -514,8 +567,16 @@ class MixCustom {
         return '';
     }
 
+    extractMessage(data) {
+        if (data.choices && data.choices[0].message.content) return data.choices[0].message.content;
+        return '';
+    }
+
     processResponse(response) {
-        return { response: response.data, message: response.data.choices[0].message.content };
+        return {
+            response: response.data,
+            message: this.extractMessage(response.data)
+        };
     }
 }
 
@@ -523,27 +584,26 @@ class MixOpenAI extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.openai.com/v1/chat/completions',
-            prefix: ['gpt', 'ft:', 'o'],
             apiKey: process.env.OPENAI_API_KEY,
             ...customConfig
         });
     }
 
-    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) {
@@ -571,21 +631,25 @@ class MixAnthropic extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.anthropic.com/v1/messages',
-            prefix: ['claude'],
             apiKey: process.env.ANTHROPIC_API_KEY,
             ...customConfig
         });
     }
 
-    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;
+        }
 
-        args.options.system = args.config.system + args.config.systemExtra;
-        return super.create(args);
+        delete options.response_format;
+
+        options.system = config.system + config.systemExtra;
+        return super.create({ config, options });
     }
 
     getDefaultHeaders(customHeaders) {
@@ -601,8 +665,18 @@ class MixAnthropic extends MixCustom {
         return '';
     }
 
-    processResponse(response) {
-        return { response: response.data, message: response.data.content[0].text };
+    extractMessage(data) {
+        if (data.content) {
+            // thinking
+            if (data.content?.[1]?.text) {
+                return data.content[1].text;
+            }
+
+            if (data.content[0].text) {
+                return data.content[0].text;
+            }
+        }
+        return '';
     }
 }
 
@@ -610,20 +684,29 @@ class MixPerplexity extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.perplexity.ai/chat/completions',
-            prefix: ['llama-3', 'mixtral'],
             apiKey: process.env.PPLX_API_KEY,
             ...customConfig
         });
     }
 
-    create(args = { config: {}, options: {} }) {
+    async create({ config = {}, options = {} } = {}) {
+
+        if (config.schema) {
+            config.systemExtra = '';
+
+            options.response_format = {
+                type: 'json_schema',
+                json_schema: { schema: config.schema }
+            };
+        }
+
         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 });
     }
 }
 
@@ -647,16 +730,16 @@ 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) {
-        return { response: response.data, message: response.data.message.content.trim() };
+    extractMessage(data) {
+        return data.message.content.trim();
     }
 
     static convertMessages(messages) {
@@ -685,7 +768,6 @@ class MixGrok extends MixOpenAI {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.x.ai/v1/chat/completions',
-            prefix: ['grok'],
             apiKey: process.env.XAI_API_KEY,
             ...customConfig
         });
@@ -700,11 +782,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 });
     }
 }
 
@@ -712,21 +794,20 @@ class MixGroq extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.groq.com/openai/v1/chat/completions',
-            prefix: ["llama", "mixtral", "gemma", "deepseek-r1-distill"],
             apiKey: process.env.GROQ_API_KEY,
             ...customConfig
         });
     }
 
-    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 });
     }
 }
 
@@ -734,7 +815,6 @@ class MixTogether extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.together.xyz/v1/chat/completions',
-            prefix: ["meta-llama", "google", "NousResearch", "deepseek-ai"],
             apiKey: process.env.TOGETHER_API_KEY,
             ...customConfig
         });
@@ -756,16 +836,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 });
     }
 }
 
@@ -773,18 +853,116 @@ class MixCerebras extends MixCustom {
     getDefaultConfig(customConfig) {
         return super.getDefaultConfig({
             url: 'https://api.cerebras.ai/v1/chat/completions',
-            prefix: ["llama"],
             apiKey: process.env.CEREBRAS_API_KEY,
             ...customConfig
         });
     }
 
-    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',
+            apiKey: process.env.GOOGLE_API_KEY,
+            ...customConfig
+        });
+    }
+
+    getDefaultHeaders(customHeaders) {
+        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 });
+        }
+    }
+
+    extractMessage(data) {
+        return data.candidates?.[0]?.content?.parts?.[0]?.text;
     }
 }
 
-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 };