modelmix 1.2.2 → 2.0.0

package/index.js

@@ -1,12 +1,11 @@
 const axios = require('axios');
-const fs = require('fs').promises;
+const fs = require('fs');
 const mime = require('mime-types');
 
 class ModelMix {
     constructor(args = { options: {}, config: {} }) {
         this.models = {};
         this.defaultOptions = {
-            model: 'gpt-4o',
             max_tokens: 2000,
             temperature: 1,
             top_p: 1,
@@ -22,7 +21,7 @@ class ModelMix {
     }
 
     attach(modelInstance) {
-        const key = modelInstance.constructor.name.replace('Model', '').toLowerCase();
+        const key = modelInstance.config.prefix.join("_");
         this.models[key] = modelInstance;
         modelInstance.queue = [];
         modelInstance.active_requests = 0;
@@ -37,7 +36,12 @@ class ModelMix {
             throw new Error(`Model with prefix matching ${modelKey} is not attached.`);
         }
 
-        const options = { ...this.defaultOptions, ...modelEntry.options, ...overOptions, model: modelKey };
+        const options = {
+            ...this.defaultOptions,
+            ...modelEntry.options,
+            ...overOptions,
+            model: modelKey
+        };
         const config = { ...this.config, ...modelEntry.config };
 
         return new MessageHandler(this, modelEntry, options, config);
@@ -91,9 +95,9 @@ class MessageHandler {
         return this;
     }
 
-    async addImage(filePath, config = { role: "user" }) {
+    addImage(filePath, config = { role: "user" }) {
         try {
-            const imageBuffer = await fs.readFile(filePath);
+            const imageBuffer = fs.readFileSync(filePath);
             const mimeType = mime.lookup(filePath);
 
             if (!mimeType || !mimeType.startsWith('image/')) {
@@ -125,13 +129,20 @@ class MessageHandler {
     }
 
     async message() {
+        this.options.stream = false;
         const response = await this.execute();
         return response.message;
     }
 
     async raw() {
-        const data = await this.execute();
-        return data.response;
+        this.options.stream = false;
+        return this.execute();
+    }
+
+    async stream(callback) {
+        this.options.stream = true;
+        this.modelEntry.streamCallback = callback;
+        return this.execute();
     }
 
     groupByRoles(messages) {
@@ -147,10 +158,9 @@ class MessageHandler {
     }
 
     async execute() {
-
         this.messages = this.groupByRoles(this.messages);
 
-        if (this.messages.length === 0) { // Only system message is present
+        if (this.messages.length === 0) {
             throw new Error("No user messages have been added. Use addMessage(prompt) to add a message.");
         }
 
@@ -171,30 +181,112 @@ class MessageHandler {
     }
 }
 
-class OpenAIModel {
-    constructor(openai, args = { options: {}, config: {} }) {
-        this.openai = openai;
+class MixCustom {
+    constructor(args = { config: {}, options: {}, headers: {} }) {
+        this.config = this.getDefaultConfig(args.config);
+        this.options = this.getDefaultOptions(args.options);
+        this.headers = this.getDefaultHeaders(args.headers);
+        this.streamCallback = null; // Definimos streamCallback aquí
+    }
 
-        this.options = {
-            frequency_penalty: 0,
-            presence_penalty: 0,
-            stream: false,
-            ...args.options
-        }
+    getDefaultOptions(customOptions) {
+        return {
+            ...customOptions
+        };
+    }
 
-        this.config = {
-            prefix: ["gpt"],
-            max_request: 1,
-            ...args.config || {}
+    getDefaultConfig(customConfig) {
+        return {
+            url: '',
+            apiKey: '',
+            prefix: [],
+            ...customConfig
+        };
+    }
+
+    getDefaultHeaders(customHeaders) {
+        return {
+            'accept': 'application/json',
+            'content-type': 'application/json',
+            'authorization': `Bearer ${this.config.apiKey}`,
+            ...customHeaders
+        };
+    }
+
+    async create(args = { config: {}, options: {} }) {
+
+        if (args.options.stream) {
+            return this.processStream(await axios.post(this.config.url, args.options, {
+                headers: this.headers,
+                responseType: 'stream'
+            }));
+        } else {
+            return this.processResponse(await axios.post(this.config.url, args.options, {
+                headers: this.headers
+            }));
         }
     }
 
-    async create(args = { options: {}, config: {} }) {
+    processStream(response) {
+        return new Promise((resolve, reject) => {
+            let raw = [];
+            let message = '';
+            let buffer = '';
+
+            response.data.on('data', chunk => {
+                buffer += chunk.toString();
+
+                let boundary;
+                while ((boundary = buffer.indexOf('\n')) !== -1) {
+                    const dataStr = buffer.slice(0, boundary).trim();
+                    buffer = buffer.slice(boundary + 1);
+
+                    const firstBraceIndex = dataStr.indexOf('{');
+                    if (dataStr === '[DONE]' || firstBraceIndex === -1) continue;
+
+                    const jsonStr = dataStr.slice(firstBraceIndex);
+                    try {
+                        const data = JSON.parse(jsonStr);
+                        if (this.streamCallback) {
+                            const delta = this.extractDelta(data);
+                            message += delta;
+                            this.streamCallback({ response: data, message, delta });
+                            raw.push(data);
+                        }
+                    } catch (error) {
+                        console.error('Error parsing JSON:', error);
+                    }
+                }
+            });
+
+            response.data.on('end', () => resolve({ response: raw, message: message.trim() }));
+            response.data.on('error', reject);
+        });
+    }
+
+    extractDelta(data) {
+        if (data.choices && data.choices[0].delta.content) return data.choices[0].delta.content;
+        return '';
+    }
+
+    processResponse(response) {
+        return { response: response.data, message: response.data.choices[0].message.content };
+    }
+}
 
+class MixOpenAI extends MixCustom {
+    getDefaultConfig(customConfig) {
+        return {
+            ...super.getDefaultConfig(customConfig),
+            url: 'https://api.openai.com/v1/chat/completions',
+            prefix: ['gpt']
+        };
+    }
+
+    create(args = { config: {}, options: {} }) {
         args.options.messages = [{ role: 'system', content: args.config.system }, ...args.options.messages || []];
         args.options.messages = this.convertMessages(args.options.messages);
-        const response = await this.openai.chat.completions.create(args.options);
-        return { response, message: response.choices[0].message.content };
+        return super.create(args);
     }
 
     convertMessages(messages) {
@@ -218,65 +310,92 @@ class OpenAIModel {
     }
 }
 
-class AnthropicModel {
-    constructor(anthropic, args = { options: {}, config: {} }) {
-        this.anthropic = anthropic;
-        this.options = {
-            temperature: 0.5,
-            ...args.options || {}
-        }
-
-        this.config = {
-            prefix: ["claude"],
-            max_request: 1,
-            ...args.config || {}
-        }
+class MixAnthropic extends MixCustom {
+    getDefaultConfig(customConfig) {
+        return {
+            ...super.getDefaultConfig(customConfig),
+            url: 'https://api.anthropic.com/v1/messages',
+            prefix: ['claude']
+        };
     }
 
-    async create(args = { config: {}, options: {} }) {
-
-        args.options.system = args.config.system;
+    getDefaultHeaders() {
+        return {
+            ...super.getDefaultHeaders(),
+            'x-api-key': this.config.apiKey,
+            'anthropic-version': '2023-06-01'
+        };
+    }
 
-        const response = await this.anthropic.messages.create(args.options);
-        const responseText = response.content[0].text;
+    extractDelta(data) {
+        if (data.delta && data.delta.text) return data.delta.text;
+        return '';
+    }
 
-        return { response, message: responseText.trim() };
+    processResponse(response) {
+        return { response: response.data, message: response.data.content[0].text };
     }
 }
 
-class CustomModel {
-    constructor(args = { config: {}, options: {} }) {
-        this.config = {
+class MixPerplexity extends MixCustom {
+    getDefaultConfig(customConfig) {
+        return {
+            ...super.getDefaultConfig(customConfig),
             url: 'https://api.perplexity.ai/chat/completions',
-            bearer: '',
-            prefix: ["pplx", "llama", "mixtral"],
-            max_request: 1,
-            ...args.config
+            prefix: ['pplx', 'llama', 'mixtral']
         };
+    }
 
-        this.options = {
-            return_citations: false,
-            return_images: false,
-            stream: false,
-            presence_penalty: 0,
-            frequency_penalty: 1,
-            ...args.options
+    create(args = { config: {}, options: {} }) {
+        args.options.messages = [{ role: 'system', content: args.config.system }, ...args.options.messages || []];
+        return super.create(args);
+    }
+}
+
+class MixOllama extends MixCustom {
+
+    getDefaultOptions(customOptions) {
+        return {
+            options: customOptions,
         };
     }
 
-    async create(args = { config: {}, options: {} }) {
+    extractDelta(data) {
+        if (data.message && data.message.content) return data.message.content;
+        return '';
+    }
+
+    create(args = { config: {}, options: {} }) {
+
+        args.options.messages = this.convertMessages(args.options.messages);
         args.options.messages = [{ role: 'system', content: args.config.system }, ...args.options.messages || []];
-        
-        const response = await axios.post(this.config.url, args.options, {
-            headers: {
-                'accept': 'application/json',
-                'authorization': `Bearer ${this.config.bearer}`,
-                'content-type': 'application/json'
-            }
-        });
+        return super.create(args);
+    }
 
-        return { response: response.data, message: response.data.choices[0].message.content };
+    processResponse(response) {
+        return { response: response.data, message: response.data.message.content.trim() };
+    }
+
+    convertMessages(messages) {
+        return messages.map(entry => {
+            let content = '';
+            let images = [];
+
+            entry.content.forEach(item => {
+                if (item.type === 'text') {
+                    content += item.text + ' ';
+                } else if (item.type === 'image') {
+                    images.push(item.source.data);
+                }
+            });
+
+            return {
+                role: entry.role,
+                content: content.trim(),
+                images: images
+            };
+        });
     }
 }
 
-module.exports = { OpenAIModel, AnthropicModel, CustomModel, ModelMix };
+module.exports = { MixCustom, ModelMix, MixAnthropic, MixOpenAI, MixPerplexity, MixOllama };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "1.2.2",
+  "version": "2.0.0",
   "description": "🧬 ModelMix - Unified API for Diverse AI Language Models.",
   "main": "index.js",
   "repository": {
@@ -20,7 +20,11 @@
     "llama",
     "mixtral",
     "nlp",
-    "chat"
+    "chat",
+    "multimodal",
+    "omni",
+    "4o",
+    "ollama"
   ],
   "author": "Martin Clasen",
   "license": "MIT",