modelmix 3.4.0 → 3.5.2

package/index.js

@@ -5,11 +5,17 @@ const log = require('lemonlog')('ModelMix');
 const Bottleneck = require('bottleneck');
 const path = require('path');
 const generateJsonSchema = require('./schema');
+const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
+const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
 
 class ModelMix {
+
     constructor({ options = {}, config = {} } = {}) {
         this.models = [];
         this.messages = [];
+        this.tools = {};
+        this.toolClient = {};
+        this.mcp = {};
         this.options = {
             max_tokens: 5000,
             temperature: 1, // 1 --> More creative, 0 --> More deterministic.
@@ -85,16 +91,25 @@ class ModelMix {
     gpt45({ options = {}, config = {} } = {}) {
         return this.attach('gpt-4.5-preview', new MixOpenAI({ options, config }));
     }
+    opus4think({ options = {}, config = {} } = {}) {
+        options = { ...MixAnthropic.thinkingOptions, ...options };
+        return this.attach('claude-opus-4-20250514', new MixAnthropic({ options, config }));
+    }
+    opus4({ options = {}, config = {} } = {}) {
+        return this.attach('claude-opus-4-20250514', new MixAnthropic({ options, config }));
+    }
+    sonnet4({ options = {}, config = {} } = {}) {
+        return this.attach('claude-sonnet-4-20250514', new MixAnthropic({ options, config }));
+    }
+    sonnet4think({ options = {}, config = {} } = {}) {
+        options = { ...MixAnthropic.thinkingOptions, ...options };
+        return this.attach('claude-sonnet-4-20250514', new MixAnthropic({ 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 = {} } = {}) {
+    sonnet37think({ options = {}, config = {} } = {}) {
+        options = { ...MixAnthropic.thinkingOptions, ...options };
         return this.attach('claude-3-7-sonnet-20250219', new MixAnthropic({ options, config }));
     }
     sonnet35({ options = {}, config = {} } = {}) {
@@ -129,8 +144,9 @@ class ModelMix {
         return this.attach('grok-3-mini-beta', new MixGrok({ options, config }));
     }
 
-    qwen3({ options = {}, config = {}, mix = { together: true } } = {}) {
+    qwen3({ options = {}, config = {}, mix = { together: true, cerebras: false } } = {}) {
         if (mix.together) this.attach('Qwen/Qwen3-235B-A22B-fp8-tput', new MixTogether({ options, config }));
+        if (mix.cerebras) this.attach('qwen-3-32b', new MixCerebras({ options, config }));
         return this;
     }
 
@@ -140,9 +156,10 @@ class ModelMix {
         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 } } = {}) {
+    maverick({ options = {}, config = {}, mix = { groq: true, together: false, lambda: 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 }));
+        if (mix.lambda) this.attach('llama-4-maverick-17b-128e-instruct-fp8', new MixLambda({ options, config }));
         return this;
     }
 
@@ -153,6 +170,11 @@ class ModelMix {
         return this;
     }
 
+    hermes3({ options = {}, config = {}, mix = { lambda: true } } = {}) {
+        this.attach('Hermes-3-Llama-3.1-405B-FP8', new MixLambda({ options, config }));
+        return this;
+    }
+
     addText(text, { role = "user" } = {}) {
         const content = [{
             type: "text",
@@ -304,11 +326,11 @@ class ModelMix {
 
     replaceKeyFromFile(key, filePath) {
         const content = this.readFile(filePath);
-        this.replace({ [key]: this.template(content, this.config.replace) });
+        this.replace({ [key]: this._template(content, this.config.replace) });
         return this;
     }
 
-    template(input, replace) {
+    _template(input, replace) {
         if (!replace) return input;
         for (const k in replace) {
             input = input.split(/([¿?¡!,"';:\(\)\.\s])/).map(x => x === k ? replace[k] : x).join("");
@@ -319,10 +341,11 @@ class ModelMix {
     groupByRoles(messages) {
         return messages.reduce((acc, currentMessage, index) => {
             if (index === 0 || currentMessage.role !== messages[index - 1].role) {
-                acc.push({
-                    role: currentMessage.role,
-                    content: currentMessage.content
-                });
+                // acc.push({
+                //     role: currentMessage.role,
+                //     content: currentMessage.content
+                // });
+                acc.push(currentMessage);
             } else {
                 acc[acc.length - 1].content = acc[acc.length - 1].content.concat(currentMessage.content);
             }
@@ -333,13 +356,13 @@ class ModelMix {
     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;
                 });
@@ -390,10 +413,12 @@ class ModelMix {
                 const currentModel = this.models[i];
                 const currentModelKey = currentModel.key;
                 const providerInstance = currentModel.provider;
+                const optionsTools = providerInstance.getOptionsTools(this.tools);
 
                 let options = {
                     ...this.options,
                     ...providerInstance.options,
+                    ...optionsTools,
                     model: currentModelKey
                 };
 
@@ -414,7 +439,29 @@ class ModelMix {
 
                     const result = await providerInstance.create({ options, config });
 
-                    this.messages.push({ role: "assistant", content: result.message });
+                    if (result.toolCalls.length > 0) {
+
+                        if (result.message) {
+                            if (result.signature) {
+                                this.messages.push({
+                                    role: "assistant", content: [{
+                                        type: "thinking",
+                                        thinking: result.think,
+                                        signature: result.signature
+                                    }]
+                                });
+                            } else {
+                                this.addText(result.message, { role: "assistant" });
+                            }
+                        }
+
+                        this.messages.push({ role: "assistant", content: result.toolCalls, tool_calls: result.toolCalls });
+
+                        const content = await this.processToolCalls(result.toolCalls);
+                        this.messages.push({ role: 'tool', content });
+
+                        return this.execute();
+                    }
 
                     if (config.debug) {
                         log.debug(`Request successful with model: ${currentModelKey}`);
@@ -444,6 +491,69 @@ class ModelMix {
             throw lastError || new Error("Failed to get response from any model, and no specific error was caught.");
         });
     }
+
+    async processToolCalls(toolCalls) {
+        const result = []
+
+        for (const toolCall of toolCalls) {
+            const client = this.toolClient[toolCall.function.name];
+
+            const response = await client.callTool({
+                name: toolCall.function.name,
+                arguments: JSON.parse(toolCall.function.arguments)
+            });
+
+            result.push({
+                name: toolCall.function.name,
+                tool_call_id: toolCall.id,
+                content: response.content.map(item => item.text).join("\n")
+            });
+        }
+        return result;
+    }
+
+    async addMCP() {
+
+        const key = arguments[0];
+
+        if (this.mcp[key]) {
+            log.info(`MCP ${key} already attached.`);
+            return;
+        }
+
+        if (this.config.max_history < 3) {
+            log.warn(`MCP ${key} requires at least 3 max_history. Setting to 3.`);
+            this.config.max_history = 3;
+        }
+
+        const env = {}
+        for (const key in process.env) {
+            if (['OPENAI', 'ANTHR', 'GOOGLE', 'GROQ', 'TOGET', 'LAMBDA', 'PPLX', 'XAI', 'CEREBR'].some(prefix => key.startsWith(prefix))) continue;
+            env[key] = process.env[key];
+        }
+
+        const transport = new StdioClientTransport({
+            command: "npx",
+            args: ["-y", ...arguments],
+            env
+        });
+
+        // Crear el cliente MCP
+        this.mcp[key] = new Client({
+            name: key,
+            version: "1.0.0"
+        });
+
+        await this.mcp[key].connect(transport);
+
+        const { tools } = await this.mcp[key].listTools();
+        this.tools[key] = tools;
+
+        for (const tool of tools) {
+            this.toolClient[tool.name] = this.mcp[key];
+        }
+
+    }
 }
 
 class MixCustom {
@@ -477,8 +587,15 @@ class MixCustom {
         };
     }
 
+    convertMessages(messages, config) {
+        return MixOpenAI.convertMessages(messages, config);
+    }
+
     async create({ config = {}, options = {} } = {}) {
         try {
+
+            options.messages = this.convertMessages(options.messages, config);
+
             if (config.debug) {
                 log.debug("config");
                 log.info(config);
@@ -562,33 +679,64 @@ class MixCustom {
     }
 
     extractDelta(data) {
-        if (data.choices && data.choices[0].delta.content) return data.choices[0].delta.content;
-        return '';
+        return data.choices[0].delta.content;
     }
 
-    extractMessage(data) {
-        if (data.choices && data.choices[0].message.content) return data.choices[0].message.content.trim();
-        return '';
+    static extractMessage(data) {
+        const message = data.choices[0].message?.content?.trim() || '';
+        const endTagIndex = message.indexOf('</think>');
+        if (message.startsWith('<think>') && endTagIndex !== -1) {
+            return message.substring(endTagIndex + 8).trim();
+        }
+        return message;
     }
 
-    processResponse(response) {
-        let message = this.extractMessage(response.data);
-
-        if (message.startsWith('<think>')) {
-            const endTagIndex = message.indexOf('</think>');
-            if (endTagIndex !== -1) {
-                const think = message.substring(7, endTagIndex).trim();
-                message = message.substring(endTagIndex + 8).trim();
-                return { response: response.data, message, think };
+    static extractThink(data) {
+
+        if (data.choices[0].message?.reasoning_content) {
+            return data.choices[0].message.reasoning_content;
+        }
+
+        const message = data.choices[0].message?.content?.trim() || '';
+        const endTagIndex = message.indexOf('</think>');
+        if (message.startsWith('<think>') && endTagIndex !== -1) {
+            return message.substring(7, endTagIndex).trim();
+        }
+        return null;
+    }
+
+    static extractToolCalls(data) {
+        return data.choices[0].message?.tool_calls?.map(call => ({
+            id: call.id,
+            type: 'function',
+            function: {
+                name: call.function.name,
+                arguments: call.function.arguments
             }
+        })) || []
+    }
+
+    processResponse(response) {
+        return {
+            message: MixCustom.extractMessage(response.data),
+            think: MixCustom.extractThink(response.data),
+            toolCalls: MixCustom.extractToolCalls(response.data),
+            response: response.data
         }
+    }
 
-        return { response: response.data, message };
+    getOptionsTools(tools) {
+        return MixOpenAI.getOptionsTools(tools);
     }
 }
 
 class MixOpenAI extends MixCustom {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.OPENAI_API_KEY) {
+            throw new Error('OpenAI API key not found. Please provide it in config or set OPENAI_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.openai.com/v1/chat/completions',
             apiKey: process.env.OPENAI_API_KEY,
@@ -597,9 +745,6 @@ class MixOpenAI extends MixCustom {
     }
 
     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 (options.model?.startsWith('o')) {
@@ -607,35 +752,85 @@ class MixOpenAI extends MixCustom {
             delete options.temperature;
         }
 
-        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) {
-        return messages.map(message => {
-            if (message.role === 'user' && message.content instanceof Array) {
-                message.content = message.content.map(content => {
+    static convertMessages(messages, config) {
+
+        const content = config.system + config.systemExtra;
+        messages = [{ role: 'system', content }, ...messages || []];
+
+        const results = []
+        for (const message of messages) {
+
+            if (message.tool_calls) {
+                results.push({ role: 'assistant', tool_calls: message.tool_calls })
+                continue;
+            }
+
+            if (message.role === 'tool') {
+                for (const content of message.content) {
+                    results.push({ role: 'tool', ...content })
+                }
+                continue;
+            }
+
+            if (Array.isArray(message.content))
+                for (const content of message.content) {
                     if (content.type === 'image') {
                         const { type, media_type, data } = content.source;
-                        return {
+                        message.content = {
                             type: 'image_url',
                             image_url: {
                                 url: `data:${media_type};${type},${data}`
                             }
                         };
                     }
-                    return content;
+                }
+
+            results.push(message);
+        }
+        return results;
+    }
+
+    static getOptionsTools(tools) {
+        const options = {};
+        options.tools = [];
+        for (const tool in tools) {
+            for (const item of tools[tool]) {
+                options.tools.push({
+                    type: 'function',
+                    function: {
+                        name: item.name,
+                        description: item.description,
+                        parameters: item.inputSchema
+                    }
                 });
             }
-            return message;
-        });
+        }
+
+        // options.tool_choice = "auto";
+
+        return options;
     }
 }
 
 class MixAnthropic extends MixCustom {
+
+    static thinkingOptions = {
+        thinking: {
+            "type": "enabled",
+            "budget_tokens": 1024
+        },
+        temperature: 1
+    };
+
     getDefaultConfig(customConfig) {
+
+        if (!process.env.ANTHROPIC_API_KEY) {
+            throw new Error('Anthropic API key not found. Please provide it in config or set ANTHROPIC_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.anthropic.com/v1/messages',
             apiKey: process.env.ANTHROPIC_API_KEY,
@@ -644,9 +839,6 @@ class MixAnthropic extends MixCustom {
     }
 
     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.');
-        }
 
         // Remove top_p for thinking
         if (options.thinking) {
@@ -659,6 +851,39 @@ class MixAnthropic extends MixCustom {
         return super.create({ config, options });
     }
 
+    convertMessages(messages, config) {
+        return MixAnthropic.convertMessages(messages, config);
+    }
+
+    static convertMessages(messages, config) {
+        return messages.map(message => {
+            if (message.role === 'tool') {
+                return {
+                    role: "user",
+                    content: message.content.map(content => ({
+                        type: "tool_result",
+                        tool_use_id: content.tool_call_id,
+                        content: content.content
+                    }))
+                }
+            }
+
+            message.content = message.content.map(content => {
+                if (content.type === 'function') {
+                    return {
+                        type: 'tool_use',
+                        id: content.id,
+                        name: content.function.name,
+                        input: JSON.parse(content.function.arguments)
+                    }
+                }
+                return content;
+            });
+
+            return message;
+        });
+    }
+
     getDefaultHeaders(customHeaders) {
         return super.getDefaultHeaders({
             'x-api-key': this.config.apiKey,
@@ -672,29 +897,77 @@ class MixAnthropic extends MixCustom {
         return '';
     }
 
-    processResponse(response) {
-        if (response.data.content) {
+    static extractToolCalls(data) {
 
-            if (response.data.content?.[1]?.text) {
+        return data.content.map(item => {
+            if (item.type === 'tool_use') {
                 return {
-                    think: response.data.content[0]?.thinking,
-                    message: response.data.content[1].text,
-                    response: response.data
-                }
+                    id: item.id,
+                    type: 'function',
+                    function: {
+                        name: item.name,
+                        arguments: JSON.stringify(item.input)
+                    }
+                };
             }
+            return null;
+        }).filter(item => item !== null);
+    }
 
-            if (response.data.content[0].text) {
-                return {
-                    message: response.data.content[0].text,
-                    response: response.data
-                }
+    static extractMessage(data) {
+        if (data.content?.[1]?.text) {
+            return data.content[1].text;
+        }
+        return data.content[0].text;
+    }
+
+    static extractThink(data) {
+        return data.content[0]?.thinking || null;
+    }
+
+    static extractSignature(data) {
+        return data.content[0]?.signature || null;
+    }
+
+    processResponse(response) {
+        return {
+            message: MixAnthropic.extractMessage(response.data),
+            think: MixAnthropic.extractThink(response.data),
+            toolCalls: MixAnthropic.extractToolCalls(response.data),
+            response: response.data,
+            signature: MixAnthropic.extractSignature(response.data)
+        }
+    }
+
+    getOptionsTools(tools) {
+        return MixAnthropic.getOptionsTools(tools);
+    }
+
+    static getOptionsTools(tools) {
+        const options = {};
+        options.tools = [];
+        for (const tool in tools) {
+            for (const item of tools[tool]) {
+                options.tools.push({
+                    type: 'custom',
+                    name: item.name,
+                    description: item.description,
+                    input_schema: item.inputSchema
+                });
             }
         }
+
+        return options;
     }
 }
 
 class MixPerplexity extends MixCustom {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.PPLX_API_KEY) {
+            throw new Error('Perplexity API key not found. Please provide it in config or set PPLX_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.perplexity.ai/chat/completions',
             apiKey: process.env.PPLX_API_KEY,
@@ -713,10 +986,6 @@ class MixPerplexity extends MixCustom {
             };
         }
 
-        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 = config.system + config.systemExtra;
         options.messages = [{ role: 'system', content }, ...options.messages || []];
         return super.create({ config, options });
@@ -743,19 +1012,18 @@ class MixOllama extends MixCustom {
         return '';
     }
 
-    async create({ config = {}, options = {} } = {}) {
-
-        options.messages = MixOllama.convertMessages(options.messages);
-        const content = config.system + config.systemExtra;
-        options.messages = [{ role: 'system', content }, ...options.messages || []];
-        return super.create({ config, options });
-    }
-
     extractMessage(data) {
         return data.message.content.trim();
     }
 
-    static convertMessages(messages) {
+    convertMessages(messages, config) {
+        return MixOllama.convertMessages(messages, config);
+    }
+
+    static convertMessages(messages, config) {
+        const content = config.system + config.systemExtra;
+        messages = [{ role: 'system', content }, ...messages || []];
+
         return messages.map(entry => {
             let content = '';
             let images = [];
@@ -779,26 +1047,31 @@ class MixOllama extends MixCustom {
 
 class MixGrok extends MixOpenAI {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.XAI_API_KEY) {
+            throw new Error('Grok API key not found. Please provide it in config or set XAI_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.x.ai/v1/chat/completions',
             apiKey: process.env.XAI_API_KEY,
             ...customConfig
         });
     }
+}
 
-    processResponse(response) {
-        const message = this.extractMessage(response.data);
-
-        const output = {
-            message: message,
-            response: response.data
-        }
+class MixLambda extends MixCustom {
+    getDefaultConfig(customConfig) {
 
-        if (response.data.choices[0].message.reasoning_content) {
-            output.think = response.data.choices[0].message.reasoning_content;
+        if (!process.env.LAMBDA_API_KEY) {
+            throw new Error('Lambda API key not found. Please provide it in config or set LAMBDA_API_KEY environment variable.');
         }
 
-        return output;
+        return super.getDefaultConfig({
+            url: 'https://api.lambda.ai/v1/chat/completions',
+            apiKey: process.env.LAMBDA_API_KEY,
+            ...customConfig
+        });
     }
 }
 
@@ -809,38 +1082,30 @@ class MixLMStudio extends MixCustom {
             ...customConfig
         });
     }
-
-    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 });
-    }
 }
 
 class MixGroq extends MixCustom {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.GROQ_API_KEY) {
+            throw new Error('Groq API key not found. Please provide it in config or set GROQ_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.groq.com/openai/v1/chat/completions',
             apiKey: process.env.GROQ_API_KEY,
             ...customConfig
         });
     }
-
-    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 = config.system + config.systemExtra;
-        options.messages = [{ role: 'system', content }, ...options.messages || []];
-        options.messages = MixOpenAI.convertMessages(options.messages);
-        return super.create({ config, options });
-    }
 }
 
 class MixTogether extends MixCustom {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.TOGETHER_API_KEY) {
+            throw new Error('Together API key not found. Please provide it in config or set TOGETHER_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.together.xyz/v1/chat/completions',
             apiKey: process.env.TOGETHER_API_KEY,
@@ -854,44 +1119,21 @@ class MixTogether extends MixCustom {
             ...customOptions
         };
     }
-
-    static convertMessages(messages) {
-        return messages.map(message => {
-            if (message.content instanceof Array) {
-                message.content = message.content.map(content => content.text).join("\n\n");
-            }
-            return message;
-        });
-    }
-
-    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 = config.system + config.systemExtra;
-        options.messages = [{ role: 'system', content }, ...options.messages || []];
-        options.messages = MixTogether.convertMessages(options.messages);
-
-        return super.create({ config, options });
-    }
 }
 
 class MixCerebras extends MixCustom {
     getDefaultConfig(customConfig) {
+
+        if (!process.env.CEREBRAS_API_KEY) {
+            throw new Error('Together API key not found. Please provide it in config or set CEREBRAS_API_KEY environment variable.');
+        }
+
         return super.getDefaultConfig({
             url: 'https://api.cerebras.ai/v1/chat/completions',
             apiKey: process.env.CEREBRAS_API_KEY,
             ...customConfig
         });
     }
-
-    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 {
@@ -899,7 +1141,6 @@ class MixGoogle extends MixCustom {
         return super.getDefaultConfig({
             url: 'https://generativelanguage.googleapis.com/v1beta/models',
             apiKey: process.env.GOOGLE_API_KEY,
-            ...customConfig
         });
     }
 
@@ -910,40 +1151,54 @@ class MixGoogle extends MixCustom {
         };
     }
 
-    getDefaultOptions(customOptions) {
-        return {
-            generationConfig: {
-                responseMimeType: "text/plain"
-            },
-            ...customOptions
-        };
-    }
-
-    static convertMessages(messages) {
+    static convertMessages(messages, config) {
         return messages.map(message => {
-            const parts = [];
 
-            if (message.content instanceof Array) {
-                message.content.forEach(content => {
+            if (!Array.isArray(message.content)) return message;
+            const role = (message.role === 'assistant' || message.role === 'tool') ? 'model' : 'user'
+
+            if (message.role === 'tool') {
+                return {
+                    role,
+                    parts: message.content.map(content => ({
+                        functionResponse: {
+                            name: content.name,
+                            response: {
+                                output: content.content,
+                            },
+                        }
+                    }))
+                }
+            }
+
+            return {
+                role,
+                parts: message.content.map(content => {
                     if (content.type === 'text') {
-                        parts.push({ text: content.text });
-                    } else if (content.type === 'image') {
-                        parts.push({
+                        return { text: content.text };
+                    }
+
+                    if (content.type === 'image') {
+                        return {
                             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
-            };
+                    if (content.type === 'function') {
+                        return {
+                            functionCall: {
+                                name: content.function.name,
+                                args: JSON.parse(content.function.arguments)
+                            }
+                        }
+                    }
+
+                    return content;
+                })
+            }
         });
     }
 
@@ -952,30 +1207,38 @@ class MixGoogle extends MixCustom {
             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}`;
+        const fullUrl = `${this.config.url}/${options.model}:${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 || '') }]
-            });
+        const content = config.system + config.systemExtra;
+        const systemInstruction = { parts: [{ text: content }] };
+
+        options.messages = MixGoogle.convertMessages(options.messages);
+
+        const generationConfig = {
+            topP: options.top_p,
+            maxOutputTokens: options.max_tokens,
         }
 
-        // Prepare the request payload
+        generationConfig.responseMimeType = "text/plain";
+
         const payload = {
-            contents,
-            generationConfig: options.generationConfig || this.getDefaultOptions().generationConfig
+            generationConfig,
+            systemInstruction,
+            contents: options.messages,
+            tools: options.tools
         };
 
         try {
+            if (config.debug) {
+                log.debug("config");
+                log.info(config);
+                log.debug("payload");
+                log.inspect(payload);
+            }
+
             if (options.stream) {
                 throw new Error('Stream is not supported for Gemini');
             } else {
@@ -988,9 +1251,59 @@ class MixGoogle extends MixCustom {
         }
     }
 
-    extractMessage(data) {
+    processResponse(response) {
+        return {
+            message: MixGoogle.extractMessage(response.data),
+            think: null,
+            toolCalls: MixGoogle.extractToolCalls(response.data),
+            response: response.data
+        }
+    }
+
+    static extractToolCalls(data) {
+        return data.candidates?.[0]?.content?.parts?.map(part => {
+            if (part.functionCall) {
+                return {
+                    id: part.functionCall.id,
+                    type: 'function',
+                    function: {
+                        name: part.functionCall.name,
+                        arguments: JSON.stringify(part.functionCall.args)
+                    }
+                };
+            }
+            return null;
+        }).filter(item => item !== null) || [];
+    }
+
+    static extractMessage(data) {
         return data.candidates?.[0]?.content?.parts?.[0]?.text;
     }
+
+    static getOptionsTools(tools) {
+        const functionDeclarations = [];
+        for (const tool in tools) {
+            for (const item of tools[tool]) {
+                functionDeclarations.push({
+                    name: item.name,
+                    description: item.description,
+                    parameters: item.inputSchema
+                });
+            }
+        }
+
+        const options = {
+            tools: [{
+                functionDeclarations
+            }]
+        };
+
+        return options;
+    }
+
+    getOptionsTools(tools) {
+        return MixGoogle.getOptionsTools(tools);
+    }
 }
 
 module.exports = { MixCustom, ModelMix, MixAnthropic, MixOpenAI, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle };