modelmix 3.8.4 → 3.8.8

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,10 +17,10 @@ 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.
-            top_p: 1, // 100% --> The model considers all possible tokens.
             ...options
         };
 
@@ -98,22 +99,14 @@ class ModelMix {
     }
     gpt5nano({ options = {}, config = {} } = {}) {
         return this.attach('gpt-5-nano', new MixOpenAI({ options, config }));
-    }    
-    gptOss({ options = {}, config = {}, mix = { together: false, cerebras: false, groq: true, lmstudio: false } } = {}) {
+    }
+    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 }));
-    }
-    opus4({ options = {}, config = {} } = {}) {
-        return this.attach('claude-opus-4-20250514', new MixAnthropic({ options, config }));
-    }
+
     opus41({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-4-1-20250805', new MixAnthropic({ options, config }));
     }
@@ -128,6 +121,13 @@ class ModelMix {
         options = { ...MixAnthropic.thinkingOptions, ...options };
         return this.attach('claude-sonnet-4-20250514', new MixAnthropic({ options, config }));
     }
+    sonnet45({ options = {}, config = {} } = {}) {
+        return this.attach('claude-sonnet-4-5-20250929', new MixAnthropic({ options, config }));
+    }
+    sonnet45think({ options = {}, config = {} } = {}) {
+        options = { ...MixAnthropic.thinkingOptions, ...options };
+        return this.attach('claude-sonnet-4-5-20250929', new MixAnthropic({ options, config }));
+    }
     sonnet37({ options = {}, config = {} } = {}) {
         return this.attach('claude-3-7-sonnet-20250219', new MixAnthropic({ options, config }));
     }
@@ -135,9 +135,6 @@ class ModelMix {
         options = { ...MixAnthropic.thinkingOptions, ...options };
         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 }));
     }
@@ -199,11 +196,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",
@@ -247,7 +248,7 @@ class ModelMix {
 
     addImage(filePath, { role = "user" } = {}) {
         const absolutePath = path.resolve(filePath);
-        
+
         if (!fs.existsSync(absolutePath)) {
             throw new Error(`Image file not found: ${filePath}`);
         }
@@ -281,11 +282,11 @@ class ModelMix {
             }
         } else {
             source = {
-                type: "url", 
+                type: "url",
                 data: url
             };
         }
-        
+
         this.messages.push({
             role,
             content: [{
@@ -293,7 +294,7 @@ class ModelMix {
                 source
             }]
         });
-        
+
         return this;
     }
 
@@ -468,7 +469,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;
     }
@@ -490,7 +512,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 () => {
@@ -552,7 +574,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 });
@@ -593,18 +615,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;
     }
@@ -651,6 +722,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 {
@@ -658,7 +779,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) {
@@ -850,7 +971,7 @@ 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) {
@@ -878,14 +999,18 @@ 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)) {
-                message.content = message.content.map(content => {
-                    if (content.type === 'image') {
+                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',
@@ -900,6 +1025,7 @@ class MixOpenAI extends MixCustom {
 
             results.push(message);
         }
+
         return results;
     }
 
@@ -950,21 +1076,19 @@ class MixAnthropic extends MixCustom {
 
     async create({ config = {}, options = {} } = {}) {
 
-        // Remove top_p for thinking
-        if (options.thinking) {
-            delete options.top_p;
-        }
-
-        if (options.model && options.model.includes('claude-opus-4-1')) {
-            if (options.temperature !== undefined && options.top_p !== undefined) {
-                delete options.top_p;
-            }
-        }
-
         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) {
@@ -972,7 +1096,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",
@@ -984,17 +1128,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;
         });
@@ -1065,7 +1223,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
@@ -1326,6 +1483,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'
 
@@ -1390,10 +1560,13 @@ class MixGoogle extends MixCustom {
         options.messages = MixGoogle.convertMessages(options.messages);
 
         const generationConfig = {
-            topP: options.top_p,
             maxOutputTokens: options.max_tokens,
         }
 
+        if (options.top_p) {
+            generationConfig.topP = options.top_p;
+        }
+
         generationConfig.responseMimeType = "text/plain";
 
         const payload = {

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.4",
+  "version": "3.8.8",
   "description": "🧬 ModelMix - Unified API for Diverse AI LLM.",
   "main": "index.js",
   "repository": {
@@ -52,7 +52,7 @@
     "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",
@@ -69,6 +69,7 @@
     "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": "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"
   }
 }

package/test/bottleneck.test.js

@@ -6,6 +6,11 @@ const Bottleneck = require('bottleneck');
 
 describe('Rate Limiting with Bottleneck Tests', () => {
     
+    // Setup test hooks
+    if (global.setupTestHooks) {
+        global.setupTestHooks();
+    }
+    
     afterEach(() => {
         nock.cleanAll();
         sinon.restore();
@@ -57,6 +62,13 @@ describe('Rate Limiting with Bottleneck Tests', () => {
             });
         });
 
+        afterEach(async () => {
+            // Clean up bottleneck state
+            if (model && model.limiter) {
+                await model.limiter.stop({ dropWaitingJobs: true });
+            }
+        });
+
         it('should enforce minimum time between requests', async () => {
             const startTimes = [];
             
@@ -162,6 +174,13 @@ describe('Rate Limiting with Bottleneck Tests', () => {
             });
         });
 
+        afterEach(async () => {
+            // Clean up bottleneck state
+            if (model && model.limiter) {
+                await model.limiter.stop({ dropWaitingJobs: true });
+            }
+        });
+
         it('should apply rate limiting to OpenAI requests', async () => {
             const requestTimes = [];
             
@@ -240,6 +259,13 @@ describe('Rate Limiting with Bottleneck Tests', () => {
             });
         });
 
+        afterEach(async () => {
+            // Clean up bottleneck state
+            if (model && model.limiter) {
+                await model.limiter.stop({ dropWaitingJobs: true });
+            }
+        });
+
         it('should handle rate limiting with API errors', async () => {
             model.gpt4o();
             

package/test/fallback.test.js

@@ -4,6 +4,11 @@ const nock = require('nock');
 const { ModelMix } = require('../index.js');
 
 describe('Provider Fallback Chain Tests', () => {
+    
+    // Setup test hooks
+    if (global.setupTestHooks) {
+        global.setupTestHooks();
+    }
 
     afterEach(() => {
         nock.cleanAll();