modelmix 3.8.4 → 3.8.8

package/README.md

@@ -39,7 +39,7 @@ import { ModelMix } from 'modelmix';
 
 // Get structured JSON responses
 const model = ModelMix.new()
-    .sonnet37() // Anthropic claude-3-7-sonnet-20250219
+    .sonnet4() // Anthropic claude-sonnet-4-20250514
     .addText("Name and capital of 3 South American countries.");
 
 const outputExample = { countries: [{ name: "", capital: "" }] };
@@ -58,9 +58,9 @@ const setup = {
 
 const model = await ModelMix.new(setup)
     .sonnet4() // (main model) Anthropic claude-sonnet-4-20250514
-    .o4mini() // (fallback 1) OpenAI o4-mini
-    .gemini25proExp({ config: { temperature: 0 } }) // (fallback 2) Google gemini-2.5-pro-exp-03-25
-    .gpt41nano() // (fallback 3) OpenAI gpt-4.1-nano
+    .gpt5mini() // (fallback 1) OpenAI gpt-5-mini
+    .gemini25flash({ config: { temperature: 0 } }) // (fallback 2) Google gemini-2.5-flash
+    .gpt5nano() // (fallback 3) OpenAI gpt-5-nano
     .grok3mini() // (fallback 4) Grok grok-3-mini
     .addText("What's your name?");
 
@@ -94,7 +94,7 @@ BRAVE_API_KEY="BSA0..._fm"
 ```
 
 ```javascript
-const mmix = ModelMix.new({ config: { max_history: 10 } }).gpt41nano();
+const mmix = ModelMix.new({ config: { max_history: 10 } }).gpt5nano();
 mmix.setSystem('You are an assistant and today is ' + new Date().toISOString());
 
 // Add web search capability through MCP
@@ -126,9 +126,8 @@ Here's a comprehensive list of available methods:
 | `o3()`             | OpenAI     | o3                             | [\$10.00 / \$40.00][1]     |
 | `gptOss()`         | Together   | gpt-oss-120B                   | [\$0.15 / \$0.60][7]       |
 | `opus41[think]()`  | Anthropic  | claude-opus-4-1-20250805       | [\$15.00 / \$75.00][2]     |
+| `sonnet45[think]()`| Anthropic  | claude-sonnet-4-5-20250929     | [\$3.00 / \$15.00][2]      |
 | `sonnet4[think]()` | Anthropic  | claude-sonnet-4-20250514       | [\$3.00 / \$15.00][2]      |
-| `sonnet37[think]()`| Anthropic  | claude-3-7-sonnet-20250219     | [\$3.00 / \$15.00][2]      |
-| `sonnet35()`       | Anthropic  | claude-3-5-sonnet-20241022     | [\$3.00 / \$15.00][2]      |
 | `haiku35()`        | Anthropic  | claude-3-5-haiku-20241022      | [\$0.80 / \$4.00][2]       |
 | `gemini25flash()`   | Google     | gemini-2.5-flash-preview-04-17  | [\$0.00 / \$0.00][3]       |
 | `gemini25proExp()` | Google     | gemini-2.5-pro-exp-03-25       | [\$0.00 / \$0.00][3]       |
@@ -331,7 +330,6 @@ new ModelMix(args = { options: {}, config: {} })
   - **options**: This object contains default options that are applied to all models. These options can be overridden when creating a specific model instance. Examples of default options include:
     - `max_tokens`: Sets the maximum number of tokens to generate, e.g., 2000.
     - `temperature`: Controls the randomness of the model's output, e.g., 1.
-    - `top_p`: Controls the diversity of the output, e.g., 1.
     - ...(Additional default options can be added as needed)
   - **config**: This object contains configuration settings that control the behavior of the `ModelMix` instance. These settings can also be overridden for specific model instances. Examples of configuration settings include:
     - `system`: Sets the default system message for the model, e.g., "You are an assistant."

package/demo/mcp-simple.mjs

@@ -0,0 +1,166 @@
+import 'dotenv/config';
+import { ModelMix } from '../index.js';
+
+console.log('🧬 ModelMix - Simple MCP Tools Demo');
+
+// Simple example: Calculator with custom tool
+async function simpleCalculator() {
+    console.log('\n=== Smart Calculator ===');
+
+    const mmix = ModelMix.new()
+        .gpt41nano()
+        .setSystem('You are a smart calculator. Use the available tools to perform calculations.');
+
+    // Add custom tool for advanced operations
+    mmix.addTool({
+        name: "advanced_math",
+        description: "Perform advanced mathematical operations like power, square root, factorial",
+        inputSchema: {
+            type: "object",
+            properties: {
+                operation: {
+                    type: "string",
+                    enum: ["power", "sqrt", "factorial", "sin", "cos", "tan"],
+                    description: "Type of operation to perform"
+                },
+                value: {
+                    type: "number",
+                    description: "Input value"
+                },
+                exponent: {
+                    type: "number",
+                    description: "Exponent for power operation (optional)"
+                }
+            },
+            required: ["operation", "value"]
+        }
+    }, async ({ operation, value, exponent }) => {
+        switch (operation) {
+            case "power":
+                if (exponent === undefined) return "Error: exponent required for power operation";
+                return `${value}^${exponent} = ${Math.pow(value, exponent)}`;
+            case "sqrt":
+                return `√${value} = ${Math.sqrt(value)}`;
+            case "factorial":
+                if (value < 0 || !Number.isInteger(value)) return "Error: factorial only works with non-negative integers";
+                let result = 1;
+                for (let i = 2; i <= value; i++) result *= i;
+                return `${value}! = ${result}`;
+            case "sin":
+                return `sin(${value}) = ${Math.sin(value)}`;
+            case "cos":
+                return `cos(${value}) = ${Math.cos(value)}`;
+            case "tan":
+                return `tan(${value}) = ${Math.tan(value)}`;
+            default:
+                return "Unknown operation";
+        }
+    });
+
+    // Also add the custom basic calculator
+    mmix.addTool({
+        name: "calculate",
+        description: "Perform basic mathematical calculations",
+        inputSchema: {
+            type: "object",
+            properties: {
+                expression: {
+                    type: "string",
+                    description: "Mathematical expression to evaluate (e.g., '2 + 2', '10 * 5')"
+                }
+            },
+            required: ["expression"]
+        }
+    }, async ({ expression }) => {
+        try {
+            // Sanitize the expression to avoid malicious code
+            const sanitized = expression.replace(/[^0-9+\-*/().\s]/g, '');
+            const result = eval(sanitized);
+            return `${expression} = ${result}`;
+        } catch (error) {
+            throw new Error(`Invalid mathematical expression: ${expression}`);
+        }
+    });
+
+    mmix.addText('Calculate 2^10, the square root of 144, and the factorial of 5');
+
+    const result = await mmix.message();
+    console.log(result);
+}
+
+// Example of tool for generating content
+async function contentGenerator() {
+    console.log('\n=== Content Generator ===');
+
+    const mmix = ModelMix.new({ config: { debug: true, max_history: 1 } })
+        .gemini25flash()
+        .setSystem('You are a creative assistant that can generate different types of content.');
+
+    // Tool for generating passwords
+    mmix.addTool({
+        name: "generate_password",
+        description: "Generate a secure password with specified criteria",
+        inputSchema: {
+            type: "object",
+            properties: {
+                length: {
+                    type: "integer",
+                    description: "Length of the password",
+                    default: 12
+                },
+                includeSymbols: {
+                    type: "boolean",
+                    description: "Include special symbols",
+                    default: true
+                },
+                includeNumbers: {
+                    type: "boolean",
+                    description: "Include numbers",
+                    default: true
+                }
+            }
+        }
+    }, async ({ length = 12, includeSymbols = true, includeNumbers = true }) => {
+
+        let password = "@@@@@@@@@@@@";
+        return `Generated password (${length} chars): ${password}`;
+    });
+
+    // Tool for generating UUID
+    mmix.addTool({
+        name: "generate_uuid",
+        description: "Generate a UUID (Universally Unique Identifier)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                version: {
+                    type: "string",
+                    enum: ["v4"],
+                    description: "UUID version",
+                    default: "v4"
+                }
+            }
+        }
+    }, async ({ version = "v4" }) => {
+        // Simple UUID v4 generator
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx';
+    });
+
+    mmix.addText('Generate a secure 16-character password with symbols and a UUID');
+
+    const result = await mmix.message();
+    console.log(result);
+}
+
+// Run examples
+async function runExamples() {
+    try {
+        // await simpleCalculator();
+        await contentGenerator();
+        console.log('\n✅ Simple examples completed');
+    } catch (error) {
+        console.error('❌ Error:', error);
+    }
+}
+
+runExamples();

package/demo/mcp-tools.mjs

@@ -0,0 +1,344 @@
+import 'dotenv/config';
+import { ModelMix } from '../index.js';
+import fs from 'fs';
+import axios from 'axios';
+
+console.log('🧬 ModelMix - MCP Tools Demo with Callbacks');
+
+// Example 1: Basic predefined tools
+async function example1() {
+    console.log('\n=== Example 1: Common Tools ===');
+    
+    const mmix = ModelMix.new({ config: { max_history: 10 } })
+        .gpt41nano();
+    
+    // Add custom tools
+    mmix.addTool({
+        name: "get_current_time",
+        description: "Get the current date and time",
+        inputSchema: {
+            type: "object",
+            properties: {
+                timezone: {
+                    type: "string",
+                    description: "Timezone (optional, defaults to UTC)"
+                }
+            }
+        }
+    }, async ({ timezone = 'UTC' }) => {
+        const now = new Date();
+        if (timezone === 'UTC') {
+            return now.toISOString();
+        }
+        return now.toLocaleString('en-US', { timeZone: timezone });
+    });
+    
+    mmix.addTool({
+        name: "calculate",
+        description: "Perform basic mathematical calculations",
+        inputSchema: {
+            type: "object",
+            properties: {
+                expression: {
+                    type: "string",
+                    description: "Mathematical expression to evaluate"
+                }
+            },
+            required: ["expression"]
+        }
+    }, async ({ expression }) => {
+        try {
+            const sanitized = expression.replace(/[^0-9+\-*/().\s]/g, '');
+            const result = eval(sanitized);
+            return `${expression} = ${result}`;
+        } catch (error) {
+            throw new Error(`Invalid mathematical expression: ${expression}`);
+        }
+    });
+
+    mmix.setSystem('You are a helpful assistant. Use the available tools when necessary.');
+    mmix.addText('What time is it and what is 15 * 23?');
+    
+    console.log(await mmix.message());
+}
+
+// Example 2: Custom tool for reading files
+async function example2() {
+    console.log('\n=== Example 2: Custom Tool - Read Files ===');
+    
+    const mmix = ModelMix.new({ config: { max_history: 10 } })
+        .gpt41nano();
+
+    // Register custom tool for reading files
+    mmix.addTool({
+        name: "read_file",
+        description: "Read the contents of a file from the filesystem",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Path to the file to read"
+                }
+            },
+            required: ["path"]
+        }
+    }, async ({ path }) => {
+        try {
+            const content = fs.readFileSync(path, 'utf8');
+            return `File content of ${path}:\n\n${content}`;
+        } catch (error) {
+            return `Error reading file ${path}: ${error.message}`;
+        }
+    });
+
+    mmix.setSystem('You are an assistant that can read files. Use the read_file tool when you need to read a file.');
+    mmix.addText('Read the contents of the package.json file and tell me what the project name and version are');
+    
+    console.log(await mmix.message());
+}
+
+// Example 3: Tool for making HTTP requests
+async function example3() {
+    console.log('\n=== Example 3: HTTP Request Tool ===');
+    
+    const mmix = ModelMix.new({ config: { max_history: 10 } })
+        .gpt41nano();
+
+    // Register tool for making HTTP requests
+    mmix.addTool({
+        name: "http_request",
+        description: "Make HTTP requests to external APIs",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to make the request to"
+                },
+                method: {
+                    type: "string",
+                    enum: ["GET", "POST", "PUT", "DELETE"],
+                    description: "HTTP method",
+                    default: "GET"
+                }
+            },
+            required: ["url"]
+        }
+    }, async ({ url, method = "GET" }) => {
+        try {
+            const response = await axios({ method, url, timeout: 5000 });
+            return `HTTP ${method} ${url}\nStatus: ${response.status}\nResponse: ${JSON.stringify(response.data, null, 2)}`;
+        } catch (error) {
+            return `Error making HTTP request to ${url}: ${error.message}`;
+        }
+    });
+
+    mmix.setSystem('You are an assistant that can make HTTP requests. Use the http_request tool when you need to get data from APIs.');
+    mmix.addText('Make a GET request to https://jsonplaceholder.typicode.com/posts/1 and tell me what information it contains');
+    
+    console.log(await mmix.message());
+}
+
+// Example 4: Multiple tools working together
+async function example4() {
+    console.log('\n=== Example 4: Multiple Tools Working Together ===');
+    
+    const mmix = ModelMix.new({ config: { max_history: 10 } })
+        .gpt41nano();
+
+    // Register multiple tools at once
+    mmix.addTools([
+        {
+            tool: {
+                name: "write_file",
+                description: "Write content to a file",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        path: {
+                            type: "string",
+                            description: "Path where to write the file"
+                        },
+                        content: {
+                            type: "string",
+                            description: "Content to write"
+                        }
+                    },
+                    required: ["path", "content"]
+                }
+            },
+            callback: async ({ path, content }) => {
+                try {
+                    fs.writeFileSync(path, content, 'utf8');
+                    return `Successfully wrote content to ${path}`;
+                } catch (error) {
+                    return `Error writing to file ${path}: ${error.message}`;
+                }
+            }
+        },
+        {
+            tool: {
+                name: "list_files",
+                description: "List files in a directory",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        directory: {
+                            type: "string",
+                            description: "Directory to list files from",
+                            default: "."
+                        }
+                    }
+                }
+            },
+            callback: async ({ directory = "." }) => {
+                try {
+                    const files = fs.readdirSync(directory);
+                    return `Files in ${directory}:\n${files.join('\n')}`;
+                } catch (error) {
+                    return `Error listing files in ${directory}: ${error.message}`;
+                }
+            }
+        }
+    ]);
+
+    // Also add time tool
+    mmix.addTool({
+        name: "get_current_time",
+        description: "Get the current date and time",
+        inputSchema: {
+            type: "object",
+            properties: {
+                timezone: {
+                    type: "string",
+                    description: "Timezone (optional, defaults to UTC)"
+                }
+            }
+        }
+    }, async ({ timezone = 'UTC' }) => {
+        const now = new Date();
+        if (timezone === 'UTC') {
+            return now.toISOString();
+        }
+        return now.toLocaleString('en-US', { timeZone: timezone });
+    });
+
+    mmix.setSystem('You are an assistant that can handle files and directories. Use the available tools as needed.');
+    mmix.addText('List the files in the current directory, then create a file called "demo-output.txt" with the current date and the list of files');
+    
+    console.log(await mmix.message());
+}
+
+// Example 5: Combining external MCP with local tools
+async function example5() {
+    console.log('\n=== Example 5: External MCP + Local Tools ===');
+    
+    const mmix = ModelMix.new({ config: { max_history: 10 } })
+        .gpt41nano();
+
+    // Add external MCP (if available)
+    try {
+        await mmix.addMCP('@modelcontextprotocol/server-brave-search');
+        console.log('✓ MCP Brave Search added');
+    } catch (error) {
+        console.log('⚠️ MCP Brave Search not available:', error.message);
+    }
+
+    // Add custom local tools
+    mmix.addTool({
+        name: "get_current_time",
+        description: "Get the current date and time",
+        inputSchema: {
+            type: "object",
+            properties: {
+                timezone: {
+                    type: "string",
+                    description: "Timezone (optional, defaults to UTC)"
+                }
+            }
+        }
+    }, async ({ timezone = 'UTC' }) => {
+        const now = new Date();
+        return timezone === 'UTC' ? now.toISOString() : now.toLocaleString('en-US', { timeZone: timezone });
+    });
+    
+    mmix.addTool({
+        name: "calculate",
+        description: "Perform basic mathematical calculations",
+        inputSchema: {
+            type: "object",
+            properties: {
+                expression: {
+                    type: "string",
+                    description: "Mathematical expression to evaluate"
+                }
+            },
+            required: ["expression"]
+        }
+    }, async ({ expression }) => {
+        const sanitized = expression.replace(/[^0-9+\-*/().\s]/g, '');
+        const result = eval(sanitized);
+        return `${expression} = ${result}`;
+    });
+
+    mmix.addTool({
+        name: "save_search_result",
+        description: "Save search results to a file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filename: {
+                    type: "string",
+                    description: "Name of the file to save results"
+                },
+                content: {
+                    type: "string",
+                    description: "Content to save"
+                }
+            },
+            required: ["filename", "content"]
+        }
+    }, async ({ filename, content }) => {
+        try {
+            const timestamp = new Date().toISOString();
+            const fullContent = `Search Results - ${timestamp}\n\n${content}`;
+            fs.writeFileSync(`search-${filename}`, fullContent, 'utf8');
+            return `Search results saved to search-${filename}`;
+        } catch (error) {
+            return `Error saving search results: ${error.message}`;
+        }
+    });
+
+    mmix.setSystem('You are an assistant that can search the internet and save results. Use the available tools.');
+    mmix.addText('Search for information about "ModelMix npm package" and save the results to a file called "modelmix-info.txt"');
+    
+    console.log(await mmix.message());
+}
+
+// Run examples
+async function runExamples() {
+    try {
+        await example1();
+        await example2();
+        await example3();
+        await example4();
+        await example5();
+        
+        console.log('\n✅ All examples completed');
+        
+        // Show registered tools
+        const mmix = ModelMix.new().gpt41nano();
+        mmix.addTool({
+            name: "example_tool",
+            description: "Example tool for demonstration",
+            inputSchema: { type: "object", properties: {} }
+        }, async () => "Example response");
+        console.log('\n📋 Available tools:', mmix.listTools());
+        
+    } catch (error) {
+        console.error('❌ Error in examples:', error);
+    }
+}
+
+runExamples();