mindcraft 0.1.4-0

package/src/models/huggingface.js

@@ -0,0 +1,86 @@
+import { toSinglePrompt } from '../utils/text.js';
+import { getKey } from '../utils/keys.js';
+import { HfInference } from "@huggingface/inference";
+
+export class HuggingFace {
+  static prefix = 'huggingface';
+  constructor(model_name, url, params) {
+    // Remove 'huggingface/' prefix if present
+    this.model_name = model_name.replace('huggingface/', '');
+    this.url = url;
+    this.params = params;
+
+    if (this.url) {
+      console.warn("Hugging Face doesn't support custom urls!");
+    }
+
+    this.huggingface = new HfInference(getKey('HUGGINGFACE_API_KEY'));
+  }
+
+  async sendRequest(turns, systemMessage) {
+    const stop_seq = '***';
+    // Build a single prompt from the conversation turns
+    const prompt = toSinglePrompt(turns, null, stop_seq);
+    // Fallback model if none was provided
+    const model_name = this.model_name || 'meta-llama/Meta-Llama-3-8B';
+    // Combine system message with the prompt
+    const input = systemMessage + "\n" + prompt;
+
+    // We'll try up to 5 times in case of partial <think> blocks for DeepSeek-R1 models.
+    const maxAttempts = 5;
+    let attempt = 0;
+    let finalRes = null;
+
+    while (attempt < maxAttempts) {
+      attempt++;
+      console.log(`Awaiting Hugging Face API response... (model: ${model_name}, attempt: ${attempt})`);
+      let res = '';
+      try {
+        // Consume the streaming response chunk by chunk
+        for await (const chunk of this.huggingface.chatCompletionStream({
+          model: model_name,
+          messages: [{ role: "user", content: input }],
+          ...(this.params || {})
+        })) {
+          res += (chunk.choices[0]?.delta?.content || "");
+        }
+      } catch (err) {
+        console.log(err);
+        res = 'My brain disconnected, try again.';
+        // Break out immediately; we only retry when handling partial <think> tags.
+        break;
+      }
+
+      // If the model is DeepSeek-R1, check for mismatched <think> blocks.
+        const hasOpenTag = res.includes("<think>");
+        const hasCloseTag = res.includes("</think>");
+
+        // If there's a partial mismatch, warn and retry the entire request.
+        if ((hasOpenTag && !hasCloseTag)) {
+          console.warn("Partial <think> block detected. Re-generating...");
+          continue;
+        }
+
+        // If both tags are present, remove the <think> block entirely.
+        if (hasOpenTag && hasCloseTag) {
+          res = res.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        }
+
+      finalRes = res;
+      break; // Exit loop if we got a valid response.
+    }
+
+    // If no valid response was obtained after max attempts, assign a fallback.
+    if (finalRes == null) {
+      console.warn("Could not get a valid <think> block or normal response after max attempts.");
+      finalRes = 'I thought too hard, sorry, try again.';
+    }
+    console.log('Received.');
+    console.log(finalRes);
+    return finalRes;
+  }
+
+  async embed(text) {
+    throw new Error('Embeddings are not supported by HuggingFace.');
+  }
+}

package/src/models/hyperbolic.js

@@ -0,0 +1,114 @@
+import { getKey } from '../utils/keys.js';
+
+export class Hyperbolic {
+    static prefix = 'hyperbolic';
+    constructor(modelName, apiUrl) {
+        this.modelName = modelName || "deepseek-ai/DeepSeek-V3";
+        this.apiUrl = apiUrl || "https://api.hyperbolic.xyz/v1/chat/completions";
+
+        // Retrieve the Hyperbolic API key from keys.js
+        this.apiKey = getKey('HYPERBOLIC_API_KEY');
+        if (!this.apiKey) {
+            throw new Error('HYPERBOLIC_API_KEY not found. Check your keys.js file.');
+        }
+    }
+
+    /**
+     * Sends a chat completion request to the Hyperbolic endpoint.
+     *
+     * @param {Array} turns - An array of message objects, e.g. [{role: 'user', content: 'Hi'}].
+     * @param {string} systemMessage - The system prompt or instruction.
+     * @param {string} stopSeq - A stopping sequence, default '***'.
+     * @returns {Promise<string>} - The model's reply.
+     */
+    async sendRequest(turns, systemMessage, stopSeq = '***') {
+        // Prepare the messages with a system prompt at the beginning
+        const messages = [{ role: 'system', content: systemMessage }, ...turns];
+
+        // Build the request payload
+        const payload = {
+            model: this.modelName,
+            messages: messages,
+            max_tokens: 8192,
+            temperature: 0.7,
+            top_p: 0.9,
+            stream: false
+        };
+
+        const maxAttempts = 5;
+        let attempt = 0;
+        let finalRes = null;
+
+        while (attempt < maxAttempts) {
+            attempt++;
+            console.log(`Awaiting Hyperbolic API response... (attempt: ${attempt})`);
+            console.log('Messages:', messages);
+
+            let completionContent = null;
+
+            try {
+                const response = await fetch(this.apiUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.apiKey}`
+                    },
+                    body: JSON.stringify(payload)
+                });
+
+                if (!response.ok) {
+                    throw new Error(`HTTP error! status: ${response.status}`);
+                }
+
+                const data = await response.json();
+                if (data?.choices?.[0]?.finish_reason === 'length') {
+                    throw new Error('Context length exceeded');
+                }
+
+                completionContent = data?.choices?.[0]?.message?.content || '';
+                console.log('Received response from Hyperbolic.');
+            } catch (err) {
+                if (
+                    (err.message === 'Context length exceeded' || err.code === 'context_length_exceeded') &&
+                    turns.length > 1
+                ) {
+                    console.log('Context length exceeded, trying again with a shorter context...');
+                    return await this.sendRequest(turns.slice(1), systemMessage, stopSeq);
+                } else {
+                    console.error(err);
+                    completionContent = 'My brain disconnected, try again.';
+                }
+            }
+
+            // Check for <think> blocks
+            const hasOpenTag = completionContent.includes("<think>");
+            const hasCloseTag = completionContent.includes("</think>");
+
+            if ((hasOpenTag && !hasCloseTag)) {
+                console.warn("Partial <think> block detected. Re-generating...");
+                continue; // Retry the request
+            }
+
+            if (hasCloseTag && !hasOpenTag) {
+                completionContent = '<think>' + completionContent;
+            }
+
+            if (hasOpenTag && hasCloseTag) {
+                completionContent = completionContent.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            }
+
+            finalRes = completionContent.replace(/<\|separator\|>/g, '*no response*');
+            break; // Valid response obtained—exit loop
+        }
+
+        if (finalRes == null) {
+            console.warn("Could not get a valid <think> block or normal response after max attempts.");
+            finalRes = 'I thought too hard, sorry, try again.';
+        }
+        return finalRes;
+    }
+
+    async embed(text) {
+        throw new Error('Embeddings are not supported by Hyperbolic.');
+    }
+}

package/src/models/lmstudio.js

@@ -0,0 +1,74 @@
+import OpenAIApi from 'openai';
+import { strictFormat } from '../utils/text.js';
+
+export class LMStudio {
+    static prefix = 'lmstudio';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+        this.openai = new OpenAIApi({
+            baseURL: url || 'http://localhost:1234/v1',
+            apiKey: 'lm-studio', // LM Studio ignores this but the client requires a non-empty value
+        });
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq='***') {
+        let messages = [{ role: 'system', content: systemMessage }].concat(strictFormat(turns));
+        let model = this.model_name || 'andy-4.1';
+        let res = null;
+
+        try {
+            console.log('Awaiting LM Studio response from model', model);
+            const pack = {
+                model,
+                messages,
+                stop: stop_seq,
+                ...(this.params || {})
+            };
+            const completion = await this.openai.chat.completions.create(pack);
+            if (completion.choices[0].finish_reason === 'length')
+                throw new Error('Context length exceeded');
+            console.log('Received.');
+            res = completion.choices[0].message.content;
+            if (res.includes('</think>')) {
+                if (!res.includes('<think>')) res = '<think>' + res;
+                res = res.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            }
+        } catch (err) {
+            if ((err.message === 'Context length exceeded' || err.code === 'context_length_exceeded') && turns.length > 1) {
+                console.log('Context length exceeded, trying again with shorter context.');
+                return await this.sendRequest(turns.slice(1), systemMessage, stop_seq);
+            } else {
+                console.log(err);
+                res = 'My brain disconnected, try again.';
+            }
+        }
+        return res;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = [...messages];
+        imageMessages.push({
+            role: 'user',
+            content: [
+                { type: 'text', text: systemMessage },
+                {
+                    type: 'image_url',
+                    image_url: { url: `data:image/jpeg;base64,${imageBuffer.toString('base64')}` }
+                }
+            ]
+        });
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+
+    async embed(text) {
+        if (text.length > 8191)
+            text = text.slice(0, 8191);
+        const embedding = await this.openai.embeddings.create({
+            model: this.model_name || 'text-embedding-nomic-embed-text-v1.5',
+            input: text,
+            encoding_format: 'float',
+        });
+        return embedding.data[0].embedding;
+    }
+}

package/src/models/mercury.js

@@ -0,0 +1,95 @@
+import OpenAIApi from 'openai';
+import { getKey, hasKey } from '../utils/keys.js';
+import { strictFormat } from '../utils/text.js';
+
+export class Mercury {
+    static prefix = 'mercury';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+        let config = {};
+        if (url)
+            config.baseURL = url;
+        else
+            config.baseURL = "https://api.inceptionlabs.ai/v1";
+
+        config.apiKey = getKey('MERCURY_API_KEY');
+
+        this.openai = new OpenAIApi(config);
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq='***') {
+        if (typeof stop_seq === 'string') {
+            stop_seq = [stop_seq];
+        } else if (!Array.isArray(stop_seq)) {
+            stop_seq = [];
+        }
+        let messages = [{'role': 'system', 'content': systemMessage}].concat(turns);
+        messages = strictFormat(messages);
+        const pack = {
+            model: this.model_name || "mercury-coder-small",
+            messages,
+            stop: stop_seq,
+            ...(this.params || {})
+        };
+
+
+        let res = null;
+
+        try {
+            console.log('Awaiting mercury api response from model', this.model_name)
+            // console.log('Messages:', messages);
+            let completion = await this.openai.chat.completions.create(pack);
+            if (completion.choices[0].finish_reason == 'length')
+                throw new Error('Context length exceeded'); 
+            console.log('Received.')
+            res = completion.choices[0].message.content;
+        }
+        catch (err) {
+            if ((err.message == 'Context length exceeded' || err.code == 'context_length_exceeded') && turns.length > 1) {
+                console.log('Context length exceeded, trying again with shorter context.');
+                return await this.sendRequest(turns.slice(1), systemMessage, stop_seq);
+            } else if (err.message.includes('image_url')) {
+                console.log(err);
+                res = 'Vision is only supported by certain models.';
+            } else {
+                console.log(err);
+                res = 'My brain disconnected, try again.';
+            }
+        }
+        return res;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = [...messages];
+        imageMessages.push({
+            role: "user",
+            content: [
+                { type: "text", text: systemMessage },
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:image/jpeg;base64,${imageBuffer.toString('base64')}`
+                    }
+                }
+            ]
+        });
+        
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+
+    async embed(text) {
+        if (text.length > 8191)
+            text = text.slice(0, 8191);
+        const embedding = await this.openai.embeddings.create({
+            model: this.model_name || "text-embedding-3-small",
+            input: text,
+            encoding_format: "float",
+        });
+        return embedding.data[0].embedding;
+    }
+
+}
+
+
+

package/src/models/mistral.js

@@ -0,0 +1,94 @@
+import { Mistral as MistralClient } from '@mistralai/mistralai';
+import { getKey } from '../utils/keys.js';
+import { strictFormat } from '../utils/text.js';
+
+export class Mistral {
+    static prefix = 'mistral';
+    #client;
+
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+
+        if (typeof url === "string") {
+            console.warn("Mistral does not support custom URL's, ignoring!");
+
+        }
+
+        if (!getKey("MISTRAL_API_KEY")) {
+            throw new Error("Mistral API Key missing, make sure to set MISTRAL_API_KEY in settings.json")
+        }
+
+        this.#client = new MistralClient(
+            {
+                apiKey: getKey("MISTRAL_API_KEY")
+            }
+        );
+
+        
+        // Prevents the following code from running when model not specified
+        if (typeof this.model_name === "undefined") return;
+
+        // get the model name without the "mistral" or "mistralai" prefix
+        // e.g "mistral/mistral-large-latest" -> "mistral-large-latest"
+        if (typeof model_name.split("/")[1] !== "undefined") {
+            this.model_name = model_name.split("/")[1];
+        }
+    }
+
+    async sendRequest(turns, systemMessage) {
+
+        let result;
+
+        try {
+            const model = this.model_name || "mistral-large-latest";
+
+            const messages = [
+                { role: "system", content: systemMessage }
+            ];
+            messages.push(...strictFormat(turns));
+
+            console.log('Awaiting mistral api response...')
+            const response  = await this.#client.chat.complete({
+                model,
+                messages,
+                ...(this.params || {})
+            });
+
+            result = response.choices[0].message.content;
+        } catch (err) {
+            if (err.message.includes("A request containing images has been given to a model which does not have the 'vision' capability.")) {
+                result = "Vision is only supported by certain models.";
+            } else {
+                result = "My brain disconnected, try again.";
+            }
+            console.log(err);
+        }
+
+        return result;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = [...messages];
+        imageMessages.push({
+            role: "user",
+            content: [
+                { type: "text", text: systemMessage },
+                {
+                    type: "image_url",
+                    imageUrl: `data:image/jpeg;base64,${imageBuffer.toString('base64')}`
+                }
+            ]
+        });
+        
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+
+    async embed(text) {
+        const embedding = await this.#client.embeddings.create({
+            model: "mistral-embed",
+            inputs: text
+        });
+        return embedding.data[0].embedding;
+    }
+}

package/src/models/novita.js

@@ -0,0 +1,71 @@
+import OpenAIApi from 'openai';
+import { getKey } from '../utils/keys.js';
+import { strictFormat } from '../utils/text.js';
+
+// llama, mistral
+export class Novita {
+	static prefix = 'novita';
+	constructor(model_name, url, params) {
+    this.model_name = model_name;
+    this.url = url || 'https://api.novita.ai/v3/openai';
+    this.params = params;
+
+
+    let config = {
+      baseURL: this.url
+    };
+    config.apiKey = getKey('NOVITA_API_KEY');
+
+    this.openai = new OpenAIApi(config);
+  }
+
+	async sendRequest(turns, systemMessage, stop_seq='***') {
+      let messages = [{'role': 'system', 'content': systemMessage}].concat(turns);
+
+      
+      messages = strictFormat(messages);
+      
+      const pack = {
+          model: this.model_name || "meta-llama/llama-4-scout-17b-16e-instruct",
+          messages,
+          stop: [stop_seq],
+          ...(this.params || {})
+      };
+
+      let res = null;
+      try {
+          console.log('Awaiting novita api response...')
+          let completion = await this.openai.chat.completions.create(pack);
+          if (completion.choices[0].finish_reason == 'length')
+              throw new Error('Context length exceeded'); 
+          console.log('Received.')
+          res = completion.choices[0].message.content;
+      }
+      catch (err) {
+          if ((err.message == 'Context length exceeded' || err.code == 'context_length_exceeded') && turns.length > 1) {
+              console.log('Context length exceeded, trying again with shorter context.');
+              return await sendRequest(turns.slice(1), systemMessage, stop_seq);
+          } else {
+            console.log(err);
+              res = 'My brain disconnected, try again.';
+          }
+      }
+      if (res.includes('<think>')) {
+        let start = res.indexOf('<think>');
+        let end = res.indexOf('</think>') + 8;
+        if (start != -1) {
+          if (end != -1) {
+            res = res.substring(0, start) + res.substring(end);
+          } else {
+            res = res.substring(0, start+7);
+          }
+        }
+        res = res.trim();
+      }
+      return res;
+  }
+
+	async embed(text) {
+		throw new Error('Embeddings are not supported by Novita AI.');
+	}
+}

package/src/models/ollama.js

@@ -0,0 +1,115 @@
+import { strictFormat } from '../utils/text.js';
+
+export class Ollama {
+    static prefix = 'ollama';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+        this.url = url || 'http://127.0.0.1:11434';
+        this.chat_endpoint = '/api/chat';
+        this.embedding_endpoint = '/api/embeddings';
+    }
+
+    async sendRequest(turns, systemMessage) {
+        let model = this.model_name || 'sweaterdog/andy-4:micro-q8_0';
+        let messages = strictFormat(turns);
+        messages.unshift({ role: 'system', content: systemMessage });
+        const maxAttempts = 5;
+        let attempt = 0;
+        let finalRes = null;
+
+        while (attempt < maxAttempts) {
+            attempt++;
+            console.log(`Awaiting local response... (model: ${model}, attempt: ${attempt})`);
+            let res = null;
+            try {
+                let apiResponse = await this.send(this.chat_endpoint, {
+                    model: model,
+                    messages: messages,
+                    stream: false,
+                    ...(this.params || {})
+                });
+                if (apiResponse) {
+                    res = apiResponse['message']['content'];
+                } else {
+                    res = 'No response data.';
+                }
+            } catch (err) {
+                if (err.message.toLowerCase().includes('context length') && turns.length > 1) {
+                    console.log('Context length exceeded, trying again with shorter context.');
+                    return await this.sendRequest(turns.slice(1), systemMessage);
+                } else {
+                    console.log(err);
+                    res = 'My brain disconnected, try again.';
+                }
+            }
+
+            const hasOpenTag = res.includes("<think>");
+            const hasCloseTag = res.includes("</think>");
+
+            if ((hasOpenTag && !hasCloseTag)) {
+                console.warn("Partial <think> block detected. Re-generating...");
+                if (attempt < maxAttempts) continue;
+            }
+            if (hasCloseTag && !hasOpenTag) {
+                res = '<think>' + res;
+            }
+            if (hasOpenTag && hasCloseTag) {
+                res = res.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+            }
+            finalRes = res;
+            break;
+        }
+
+        if (finalRes == null) {
+            console.warn("Could not get a valid response after max attempts.");
+            finalRes = 'I thought too hard, sorry, try again.';
+        }
+        return finalRes;
+    }
+
+    async embed(text) {
+        let model = this.model_name || 'embeddinggemma';
+        let body = { model: model, input: text };
+        let res = await this.send(this.embedding_endpoint, body);
+        return res['embedding'];
+    }
+
+    async send(endpoint, body) {
+        const url = new URL(endpoint, this.url);
+        let method = 'POST';
+        let headers = new Headers();
+        const request = new Request(url, { method, headers, body: JSON.stringify(body) });
+        let data = null;
+        try {
+            const res = await fetch(request);
+            if (res.ok) {
+                data = await res.json();
+            } else {
+                throw new Error(`Ollama Status: ${res.status}`);
+            }
+        } catch (err) {
+            console.error('Failed to send Ollama request.');
+            console.error(err);
+        }
+        return data;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = [...messages];
+        imageMessages.push({
+            role: "user",
+            content: [
+                { type: "text", text: systemMessage },
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:image/jpeg;base64,${imageBuffer.toString('base64')}`
+                    }
+                }
+            ]
+        });
+        
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+}