modelmix 3.8.2 → 3.8.6

package/index.js

@@ -7,6 +7,7 @@ const path = require('path');
 const generateJsonSchema = require('./schema');
 const { Client } = require("@modelcontextprotocol/sdk/client/index.js");
 const { StdioClientTransport } = require("@modelcontextprotocol/sdk/client/stdio.js");
+const { MCPToolsManager } = require('./mcp-tools');
 
 class ModelMix {
 
@@ -16,6 +17,7 @@ class ModelMix {
         this.tools = {};
         this.toolClient = {};
         this.mcp = {};
+        this.mcpToolsManager = new MCPToolsManager();
         this.options = {
             max_tokens: 5000,
             temperature: 1, // 1 --> More creative, 0 --> More deterministic.
@@ -41,6 +43,7 @@ class ModelMix {
 
     }
 
+
     replace(keyValues) {
         this.config.replace = { ...this.config.replace, ...keyValues };
         return this;
@@ -68,7 +71,6 @@ class ModelMix {
         return this;
     }
 
-    // --- Model addition methods ---
     gpt41({ options = {}, config = {} } = {}) {
         return this.attach('gpt-4.1', new MixOpenAI({ options, config }));
     }
@@ -90,13 +92,22 @@ class ModelMix {
     gpt45({ options = {}, config = {} } = {}) {
         return this.attach('gpt-4.5-preview', new MixOpenAI({ options, config }));
     }
-    gptOss({ options = {}, config = {}, mix = { together: false, cerebras: false, groq: true, lmstudio: false } } = {}) {
+    gpt5({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-5', new MixOpenAI({ options, config }));
+    }
+    gpt5mini({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-5-mini', new MixOpenAI({ options, config }));
+    }
+    gpt5nano({ options = {}, config = {} } = {}) {
+        return this.attach('gpt-5-nano', new MixOpenAI({ options, config }));
+    }    
+    gptOss({ options = {}, config = {}, mix = { together: false, cerebras: false, groq: true } } = {}) {
         if (mix.together) return this.attach('openai/gpt-oss-120b', new MixTogether({ options, config }));
         if (mix.cerebras) return this.attach('gpt-oss-120b', new MixCerebras({ options, config }));
         if (mix.groq) return this.attach('openai/gpt-oss-120b', new MixGroq({ options, config }));
-        if (mix.lmstudio) return this.attach('openai/gpt-oss-120b', new MixLMStudio({ options, config }));
         return this;
     }
+    
     opus4think({ options = {}, config = {} } = {}) {
         options = { ...MixAnthropic.thinkingOptions, ...options };
         return this.attach('claude-opus-4-20250514', new MixAnthropic({ options, config }));
@@ -132,7 +143,7 @@ class ModelMix {
         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 }));
+        return this.attach('gemini-2.5-flash', new MixGoogle({ options, config }));
     }
     gemini25proExp({ options = {}, config = {} } = {}) {
         return this.attach('gemini-2.5-pro-exp-03-25', new MixGoogle({ options, config }));
@@ -189,11 +200,15 @@ class ModelMix {
     }
 
     kimiK2({ options = {}, config = {}, mix = { together: false, groq: true } } = {}) {
-        if (mix.together) this.attach('moonshotai/Kimi-K2-Instruct', new MixTogether({ options, config }));
-        if (mix.groq) this.attach('moonshotai/kimi-k2-instruct', new MixGroq({ options, config }));
+        if (mix.together) this.attach('moonshotai/Kimi-K2-Instruct-0905', new MixTogether({ options, config }));
+        if (mix.groq) this.attach('moonshotai/kimi-k2-instruct-0905', new MixGroq({ options, config }));
         return this;
     }
 
+    lmstudio({ options = {}, config = {} } = {}) {
+        return this.attach('lmstudio', new MixLMStudio({ options, config }));
+    }
+
     addText(text, { role = "user" } = {}) {
         const content = [{
             type: "text",
@@ -236,6 +251,12 @@ class ModelMix {
     }
 
     addImage(filePath, { role = "user" } = {}) {
+        const absolutePath = path.resolve(filePath);
+        
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`Image file not found: ${filePath}`);
+        }
+
         this.messages.push({
             role,
             content: [{
@@ -250,24 +271,41 @@ class ModelMix {
     }
 
     addImageFromUrl(url, { role = "user" } = {}) {
+        let source;
+        if (url.startsWith('data:')) {
+            // Parse data URL: data:image/jpeg;base64,/9j/4AAQ...
+            const match = url.match(/^data:([^;]+);base64,(.+)$/);
+            if (match) {
+                source = {
+                    type: "base64",
+                    media_type: match[1],
+                    data: match[2]
+                };
+            } else {
+                throw new Error('Invalid data URL format');
+            }
+        } else {
+            source = {
+                type: "url", 
+                data: url
+            };
+        }
+        
         this.messages.push({
             role,
             content: [{
                 type: "image",
-                source: {
-                    type: "url",
-                    data: url
-                }
+                source
             }]
         });
+        
         return this;
     }
 
     async processImages() {
-        // Process images that are in messages
         for (let i = 0; i < this.messages.length; i++) {
             const message = this.messages[i];
-            if (!message.content) continue;
+            if (!Array.isArray(message.content)) continue;
 
             for (let j = 0; j < message.content.length; j++) {
                 const content = message.content[j];
@@ -381,8 +419,13 @@ class ModelMix {
     }
 
     replaceKeyFromFile(key, filePath) {
-        const content = this.readFile(filePath);
-        this.replace({ [key]: this._template(content, this.config.replace) });
+        try {
+            const content = this.readFile(filePath);
+            this.replace({ [key]: this._template(content, this.config.replace) });
+        } catch (error) {
+            // Gracefully handle file read errors without throwing
+            log.warn(`replaceKeyFromFile: ${error.message}`);
+        }
         return this;
     }
 
@@ -430,7 +473,28 @@ class ModelMix {
     async prepareMessages() {
         await this.processImages();
         this.applyTemplate();
-        this.messages = this.messages.slice(-this.config.max_history);
+        
+        // Smart message slicing to preserve tool call sequences
+        if (this.config.max_history > 0) {
+            let sliceStart = Math.max(0, this.messages.length - this.config.max_history);
+            
+            // If we're slicing and there's a tool message at the start, 
+            // ensure we include the preceding assistant message with tool_calls
+            while (sliceStart > 0 && 
+                   sliceStart < this.messages.length && 
+                   this.messages[sliceStart].role === 'tool') {
+                sliceStart--;
+                // Also need to include the assistant message with tool_calls
+                if (sliceStart > 0 && 
+                    this.messages[sliceStart].role === 'assistant' && 
+                    this.messages[sliceStart].tool_calls) {
+                    break;
+                }
+            }
+            
+            this.messages = this.messages.slice(sliceStart);
+        }
+        
         this.messages = this.groupByRoles(this.messages);
         this.options.messages = this.messages;
     }
@@ -452,7 +516,7 @@ class ModelMix {
 
     async execute({ config = {}, options = {} } = {}) {
         if (!this.models || this.models.length === 0) {
-            throw new Error("No models specified. Use methods like .gpt41mini(), .sonnet4() first.");
+            throw new Error("No models specified. Use methods like .gpt5(), .sonnet4() first.");
         }
 
         return this.limiter.schedule(async () => {
@@ -514,7 +578,7 @@ class ModelMix {
                             }
                         }
 
-                        this.messages.push({ role: "assistant", content: result.toolCalls, tool_calls: result.toolCalls });
+                        this.messages.push({ role: "assistant", content: null, tool_calls: result.toolCalls });
 
                         const content = await this.processToolCalls(result.toolCalls);
                         this.messages.push({ role: 'tool', content });
@@ -555,18 +619,67 @@ class ModelMix {
         const result = []
 
         for (const toolCall of toolCalls) {
-            const client = this.toolClient[toolCall.function.name];
+            // Handle different tool call formats more robustly
+            let toolName, toolArgs, toolId;
+            
+            try {
+                if (toolCall.function) {
+                    // Formato OpenAI/normalizado
+                    toolName = toolCall.function.name;
+                    toolArgs = typeof toolCall.function.arguments === 'string' 
+                        ? JSON.parse(toolCall.function.arguments) 
+                        : toolCall.function.arguments;
+                    toolId = toolCall.id;
+                } else if (toolCall.name) {
+                    // Formato directo (posible formato alternativo)
+                    toolName = toolCall.name;
+                    toolArgs = toolCall.input || toolCall.arguments || {};
+                    toolId = toolCall.id;
+                } else {
+                    console.error('Unknown tool call format:', JSON.stringify(toolCall, null, 2));
+                    continue;
+                }
 
-            const response = await client.callTool({
-                name: toolCall.function.name,
-                arguments: JSON.parse(toolCall.function.arguments)
-            });
+                // Validar que tenemos los datos necesarios
+                if (!toolName) {
+                    console.error('Tool call missing name:', JSON.stringify(toolCall, null, 2));
+                    continue;
+                }
 
-            result.push({
-                name: toolCall.function.name,
-                tool_call_id: toolCall.id,
-                content: response.content.map(item => item.text).join("\n")
-            });
+                // Verificar si es una herramienta local registrada
+                if (this.mcpToolsManager.hasTool(toolName)) {
+                    const response = await this.mcpToolsManager.executeTool(toolName, toolArgs);
+                    result.push({
+                        name: toolName,
+                        tool_call_id: toolId,
+                        content: response.content.map(item => item.text).join("\n")
+                    });
+                } else {
+                    // Usar el cliente MCP externo
+                    const client = this.toolClient[toolName];
+                    if (!client) {
+                        throw new Error(`No client found for tool: ${toolName}`);
+                    }
+
+                    const response = await client.callTool({
+                        name: toolName,
+                        arguments: toolArgs
+                    });
+
+                    result.push({
+                        name: toolName,
+                        tool_call_id: toolId,
+                        content: response.content.map(item => item.text).join("\n")
+                    });
+                }
+            } catch (error) {
+                console.error(`Error processing tool call ${toolName}:`, error);
+                result.push({
+                    name: toolName || 'unknown',
+                    tool_call_id: toolId || 'unknown',
+                    content: `Error: ${error.message}`
+                });
+            }
         }
         return result;
     }
@@ -613,6 +726,56 @@ class ModelMix {
         }
 
     }
+
+    addTool(toolDefinition, callback) {
+
+        if (this.config.max_history < 3) {
+            log.warn(`MCP ${toolDefinition.name} requires at least 3 max_history. Setting to 3.`);
+            this.config.max_history = 3;
+        }
+
+        this.mcpToolsManager.registerTool(toolDefinition, callback);
+        
+        // Agregar la herramienta al sistema de tools para que sea incluida en las requests
+        if (!this.tools.local) {
+            this.tools.local = [];
+        }
+        this.tools.local.push({
+            name: toolDefinition.name,
+            description: toolDefinition.description,
+            inputSchema: toolDefinition.inputSchema
+        });
+        
+        return this;
+    }
+
+    addTools(toolsWithCallbacks) {
+        for (const { tool, callback } of toolsWithCallbacks) {
+            this.addTool(tool, callback);
+        }
+        return this;
+    }
+
+    removeTool(toolName) {
+        this.mcpToolsManager.removeTool(toolName);
+        
+        // Also remove from the tools system
+        if (this.tools.local) {
+            this.tools.local = this.tools.local.filter(tool => tool.name !== toolName);
+        }
+        
+        return this;
+    }
+
+    listTools() {
+        const localTools = this.mcpToolsManager.getToolsForMCP();
+        const mcpTools = Object.values(this.tools).flat();
+        
+        return {
+            local: localTools,
+            mcp: mcpTools.filter(tool => !localTools.find(local => local.name === tool.name))
+        };
+    }
 }
 
 class MixCustom {
@@ -620,7 +783,7 @@ class MixCustom {
         this.config = this.getDefaultConfig(config);
         this.options = this.getDefaultOptions(options);
         this.headers = this.getDefaultHeaders(headers);
-        this.streamCallback = null; // Definimos streamCallback aquí
+        this.streamCallback = null; // Define streamCallback here
     }
 
     getDefaultOptions(customOptions) {
@@ -812,6 +975,15 @@ class MixOpenAI extends MixCustom {
             delete options.max_tokens;
             delete options.temperature;
         }
+        
+        // Use max_completion_tokens and remove temperature for GPT-5 models
+        if (options.model?.includes('gpt-5')) {
+            if (options.max_tokens) {
+                options.max_completion_tokens = options.max_tokens;
+                delete options.max_tokens;
+            }
+            delete options.temperature;
+        }
 
         return super.create({ config, options });
     }
@@ -831,26 +1003,33 @@ class MixOpenAI extends MixCustom {
 
             if (message.role === 'tool') {
                 for (const content of message.content) {
-                    results.push({ role: 'tool', ...content })
+                    results.push({ 
+                        role: 'tool', 
+                        tool_call_id: content.tool_call_id,
+                        content: content.content 
+                    })
                 }
                 continue;
             }
 
-            if (Array.isArray(message.content))
-                for (const content of message.content) {
-                    if (content.type === 'image') {
-                        const { type, media_type, data } = content.source;
-                        message.content = [{
+            if (Array.isArray(message.content)) {
+                message.content = message.content.filter(content => content !== null && content !== undefined).map(content => {
+                    if (content && content.type === 'image') {
+                        const { media_type, data } = content.source;
+                        return {
                             type: 'image_url',
                             image_url: {
-                                url: `data:${media_type};${type},${data}`
+                                url: `data:${media_type};base64,${data}`
                             }
-                        }];
+                        };
                     }
-                }
+                    return content;
+                });
+            }
 
             results.push(message);
         }
+        
         return results;
     }
 
@@ -915,7 +1094,16 @@ class MixAnthropic extends MixCustom {
         delete options.response_format;
 
         options.system = config.system;
-        return super.create({ config, options });
+        
+        try {
+            return await super.create({ config, options });
+        } catch (error) {
+            // Log the error details for debugging
+            if (error.response && error.response.data) {
+                console.error('Anthropic API Error:', JSON.stringify(error.response.data, null, 2));
+            }
+            throw error;
+        }
     }
 
     convertMessages(messages, config) {
@@ -923,7 +1111,27 @@ class MixAnthropic extends MixCustom {
     }
 
     static convertMessages(messages, config) {
-        return messages.map(message => {
+        // Filter out orphaned tool results for Anthropic
+        const filteredMessages = [];
+        for (let i = 0; i < messages.length; i++) {
+            if (messages[i].role === 'tool') {
+                // Check if there's a preceding assistant message with tool_calls
+                let foundToolCall = false;
+                for (let j = i - 1; j >= 0; j--) {
+                    if (messages[j].role === 'assistant' && messages[j].tool_calls) {
+                        foundToolCall = true;
+                        break;
+                    }
+                }
+                if (!foundToolCall) {
+                    // Skip orphaned tool results
+                    continue;
+                }
+            }
+            filteredMessages.push(messages[i]);
+        }
+        
+        return filteredMessages.map(message => {
             if (message.role === 'tool') {
                 return {
                     role: "user",
@@ -935,17 +1143,31 @@ class MixAnthropic extends MixCustom {
                 }
             }
 
-            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)
+            // Handle messages with tool_calls (assistant messages that call tools)
+            if (message.tool_calls) {
+                const content = message.tool_calls.map(call => ({
+                    type: 'tool_use',
+                    id: call.id,
+                    name: call.function.name,
+                    input: JSON.parse(call.function.arguments)
+                }));
+                return { role: 'assistant', content };
+            }
+
+            // Handle content conversion for other messages
+            if (message.content && Array.isArray(message.content)) {
+                message.content = message.content.filter(content => content !== null && content !== undefined).map(content => {
+                    if (content && content.type === 'function') {
+                        return {
+                            type: 'tool_use',
+                            id: content.id,
+                            name: content.function.name,
+                            input: JSON.parse(content.function.arguments)
+                        }
                     }
-                }
-                return content;
-            });
+                    return content;
+                });
+            }
 
             return message;
         });
@@ -1016,7 +1238,6 @@ class MixAnthropic extends MixCustom {
         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
@@ -1277,6 +1498,19 @@ class MixGoogle extends MixCustom {
     static convertMessages(messages, config) {
         return messages.map(message => {
 
+            // Handle assistant messages with tool_calls (content is null)
+            if (message.role === 'assistant' && message.tool_calls) {
+                return {
+                    role: 'model',
+                    parts: message.tool_calls.map(toolCall => ({
+                        functionCall: {
+                            name: toolCall.function.name,
+                            args: JSON.parse(toolCall.function.arguments)
+                        }
+                    }))
+                }
+            }
+
             if (!Array.isArray(message.content)) return message;
             const role = (message.role === 'assistant' || message.role === 'tool') ? 'model' : 'user'
 

package/mcp-tools.js

@@ -0,0 +1,96 @@
+const log = require('lemonlog')('ModelMix:MCP-Tools');
+
+class MCPToolsManager {
+    constructor() {
+        this.tools = new Map();
+        this.callbacks = new Map();
+    }
+
+    registerTool(toolDefinition, callback) {
+        const { name, description, inputSchema } = toolDefinition;
+        
+        if (!name || !description || !inputSchema) {
+            throw new Error('Tool definition must include name, description, and inputSchema');
+        }
+
+        if (typeof callback !== 'function') {
+            throw new Error('Callback must be a function');
+        }
+
+        // Registrar la herramienta
+        this.tools.set(name, {
+            name,
+            description,
+            inputSchema
+        });
+
+        // Registrar el callback
+        this.callbacks.set(name, callback);
+
+        log.debug(`Tool registered: ${name}`);
+    }
+
+    registerTools(toolsWithCallbacks) {
+        for (const { tool, callback } of toolsWithCallbacks) {
+            this.registerTool(tool, callback);
+        }
+    }
+
+    async executeTool(name, args) {
+        const callback = this.callbacks.get(name);
+        if (!callback) {
+            throw new Error(`Tool not found: ${name}`);
+        }
+
+        try {
+            const result = await callback(args);
+            // For primitive values (numbers, booleans), convert to string
+            // For objects/arrays, stringify them
+            let textResult;
+            if (typeof result === 'string') {
+                textResult = result;
+            } else if (typeof result === 'number' || typeof result === 'boolean') {
+                textResult = String(result);
+            } else {
+                textResult = JSON.stringify(result, null, 2);
+            }
+            
+            return {
+                content: [{ 
+                    type: "text", 
+                    text: textResult
+                }]
+            };
+        } catch (error) {
+            log.error(`Error executing tool ${name}:`, error);
+            return {
+                content: [{ 
+                    type: "text", 
+                    text: `Error executing ${name}: ${error.message}`
+                }]
+            };
+        }
+    }
+
+    getToolsForMCP() {
+        return Array.from(this.tools.values());
+    }
+
+    hasTool(name) {
+        return this.tools.has(name);
+    }
+
+    removeTool(name) {
+        this.tools.delete(name);
+        this.callbacks.delete(name);
+        log.debug(`Tool removed: ${name}`);
+    }
+
+    clear() {
+        this.tools.clear();
+        this.callbacks.clear();
+        log.debug('All tools cleared');
+    }
+}
+
+module.exports = { MCPToolsManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "3.8.2",
+  "version": "3.8.6",
   "description": "🧬 ModelMix - Unified API for Diverse AI LLM.",
   "main": "index.js",
   "repository": {
@@ -15,13 +15,14 @@
     "openai",
     "anthropic",
     "agent",
-    "perplexity",
     "grok4",
     "gpt",
     "claude",
     "llama",
+    "fallback",
     "kimi",
     "chat",
+    "gpt5",
     "opus",
     "sonnet",
     "multimodal",
@@ -29,18 +30,14 @@
     "gemini",
     "ollama",
     "lmstudio",
-    "together",
     "nano",
     "deepseek",
     "oss",
-    "4.1",
-    "qwen",
     "nousresearch",
     "reasoning",
     "bottleneck",
     "cerebras",
     "scout",
-    "fallback",
     "clasen"
   ],
   "author": "Martin Clasen",
@@ -55,6 +52,24 @@
     "bottleneck": "^2.19.5",
     "file-type": "^16.5.4",
     "form-data": "^4.0.4",
-    "lemonlog": "^1.1.2"
+    "lemonlog": "^1.2.0"
+  },
+  "devDependencies": {
+    "chai": "^5.2.1",
+    "dotenv": "^17.2.1",
+    "mocha": "^11.7.1",
+    "nock": "^14.0.9",
+    "sinon": "^21.0.0"
+  },
+  "scripts": {
+    "test": "mocha test/**/*.js --timeout 10000 --require dotenv/config --require test/setup.js",
+    "test:watch": "mocha test/**/*.js --watch --timeout 10000 --require test/setup.js",
+    "test:json": "mocha test/json.test.js --timeout 10000 --require test/setup.js",
+    "test:fallback": "mocha test/fallback.test.js --timeout 10000 --require test/setup.js",
+    "test:templates": "mocha test/templates.test.js --timeout 10000 --require test/setup.js",
+    "test:images": "mocha test/images.test.js --timeout 10000 --require test/setup.js",
+    "test:bottleneck": "mocha test/bottleneck.test.js --timeout 10000 --require test/setup.js",
+    "test:live": "mocha test/live.test.js --timeout 10000 --require dotenv/config --require test/setup.js",
+    "test:live.mcp": "mocha test/live.mcp.js --timeout 60000 --require dotenv/config --require test/setup.js"
   }
 }