mindcraft 0.1.4-0

package/src/models/deepseek.js

@@ -0,0 +1,59 @@
+import OpenAIApi from 'openai';
+import { getKey, hasKey } from '../utils/keys.js';
+import { strictFormat } from '../utils/text.js';
+
+export class DeepSeek {
+    static prefix = 'deepseek';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+
+        let config = {};
+
+        config.baseURL = url || 'https://api.deepseek.com';
+        config.apiKey = getKey('DEEPSEEK_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 || "deepseek-chat",
+            messages,
+            stop: stop_seq,
+            ...(this.params || {})
+        };
+
+        let res = null;
+        try {
+            console.log('Awaiting deepseek api response...')
+            // 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 {
+                console.log(err);
+                res = 'My brain disconnected, try again.';
+            }
+        }
+        return res;
+    }
+
+    async embed(text) {
+        throw new Error('Embeddings are not supported by Deepseek.');
+    }
+}
+
+
+

package/src/models/gemini.js

@@ -0,0 +1,176 @@
+import { GoogleGenAI } from '@google/genai';
+import { strictFormat } from '../utils/text.js';
+import { getKey } from '../utils/keys.js';
+
+
+export class Gemini {
+    static prefix = 'google';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+        this.safetySettings = [
+            {
+                "category": "HARM_CATEGORY_DANGEROUS",
+                "threshold": "BLOCK_NONE",
+            },
+            {
+                "category": "HARM_CATEGORY_HARASSMENT",
+                "threshold": "BLOCK_NONE",
+            },
+            {
+                "category": "HARM_CATEGORY_HATE_SPEECH",
+                "threshold": "BLOCK_NONE",
+            },
+            {
+                "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                "threshold": "BLOCK_NONE",
+            },
+            {
+                "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+                "threshold": "BLOCK_NONE",
+            },
+        ];
+
+        this.genAI = new GoogleGenAI({apiKey: getKey('GEMINI_API_KEY')});
+    }
+
+    async sendRequest(turns, systemMessage) {
+        console.log('Awaiting Google API response...');
+
+        turns = strictFormat(turns);
+        let contents = [];
+        for (let turn of turns) {
+            contents.push({
+                role: turn.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: turn.content }]
+            });
+        }
+
+        const result = await this.genAI.models.generateContent({
+            model: this.model_name || "gemini-2.5-flash",
+            contents: contents,
+            safetySettings: this.safetySettings,
+            config: {
+                systemInstruction: systemMessage,
+                ...(this.params || {})
+            }
+        });
+        const response = await result.text;
+
+        console.log('Received.');
+
+        return response;
+    }
+
+    async sendVisionRequest(turns, systemMessage, imageBuffer) {
+        const imagePart = {
+            inlineData: {
+                data: imageBuffer.toString('base64'),
+                mimeType: 'image/jpeg'
+            }
+        };
+       
+        turns = strictFormat(turns);
+        let contents = [];
+        for (let turn of turns) {
+            contents.push({
+                role: turn.role === 'assistant' ? 'model' : 'user',
+                parts: [{ text: turn.content }]
+            });
+        }
+        contents.push({
+            role: 'user',
+            parts: [{ text: 'SYSTEM: Vision response' }, imagePart]
+        })
+
+        let res = null;
+        try {
+            console.log('Awaiting Google API vision response...');
+            const result = await this.genAI.models.generateContent({
+                model: this.model_name,
+                contents: contents,
+                safetySettings: this.safetySettings,
+                generationConfig: {
+                    ...(this.params || {})
+                },
+                systemInstruction: systemMessage
+            });
+            res = await result.text;
+            console.log('Received.');
+        } catch (err) {
+            console.log(err);
+            if (err.message.includes("Image input modality is not enabled for models/")) {
+                res = "Vision is only supported by certain models.";
+            } else {
+                res = "An unexpected error occurred, please try again.";
+            }
+        }
+        return res;
+    }
+
+    async embed(text) {
+        const result = await this.genAI.models.embedContent({
+            model: this.model_name || "gemini-embedding-001",
+            contents: text,
+        })
+
+        return result.embeddings;
+    }
+}
+
+const sendAudioRequest = async (text, model, voice, url) => {
+    const ai = new GoogleGenAI({apiKey: getKey('GEMINI_API_KEY')});
+
+    const response = await ai.models.generateContent({
+        model: model,
+        contents: [{ parts: [{text: text}] }],
+        config: {
+            responseModalities: ['AUDIO'],
+            speechConfig: {
+                voiceConfig: {
+                    prebuiltVoiceConfig: { voiceName: voice },
+                },
+            },
+        },
+    })
+
+    const pcmBase64 = response.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
+    if (!pcmBase64) {
+        console.warn('Gemini TTS: no audio data returned');
+        return null;
+    }
+
+    // Wrap PCM in a minimal WAV container so ffplay can decode it.
+    const pcmBuffer = Buffer.from(pcmBase64, 'base64');
+    const wavHeader = createWavHeader(pcmBuffer.length, 24000, 1, 16);
+    const wavBuffer = Buffer.concat([wavHeader, pcmBuffer]);
+
+    const wavBase64 = wavBuffer.toString('base64');
+    return wavBase64;
+}
+
+// helper: create PCM WAV header
+function createWavHeader(dataLength, sampleRate, channels, bitsPerSample) {
+    const header = Buffer.alloc(44);
+    const byteRate = sampleRate * channels * bitsPerSample / 8;
+    const blockAlign = channels * bitsPerSample / 8;
+
+    header.write('RIFF', 0);
+    header.writeUInt32LE(36 + dataLength, 4);
+    header.write('WAVE', 8);
+    header.write('fmt ', 12);
+    header.writeUInt32LE(16, 16); // PCM
+    header.writeUInt16LE(1, 20); // Audio format = PCM
+    header.writeUInt16LE(channels, 22);
+    header.writeUInt32LE(sampleRate, 24);
+    header.writeUInt32LE(byteRate, 28);
+    header.writeUInt16LE(blockAlign, 32);
+    header.writeUInt16LE(bitsPerSample, 34);
+    header.write('data', 36);
+    header.writeUInt32LE(dataLength, 40);
+    return header;
+}
+
+export const TTSConfig = {
+    sendAudioRequest: sendAudioRequest,
+}

package/src/models/glhf.js

@@ -0,0 +1,71 @@
+import OpenAIApi from 'openai';
+import { getKey } from '../utils/keys.js';
+
+export class GLHF {
+    static prefix = 'glhf';
+    constructor(model_name, url) {
+        this.model_name = model_name;
+        const apiKey = getKey('GHLF_API_KEY');
+        if (!apiKey) {
+            throw new Error('API key not found. Please check keys.json and ensure GHLF_API_KEY is defined.');
+        }
+        this.openai = new OpenAIApi({
+            apiKey,
+            baseURL: url || "https://glhf.chat/api/openai/v1"
+        });
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq = '***') {
+        // Construct the message array for the API request.
+        let messages = [{ role: 'system', content: systemMessage }].concat(turns);
+        const pack = {
+            model: this.model_name || "hf:meta-llama/Llama-3.1-405B-Instruct",
+            messages,
+            stop: [stop_seq]
+        };
+
+        const maxAttempts = 5;
+        let attempt = 0;
+        let finalRes = null;
+
+        while (attempt < maxAttempts) {
+            attempt++;
+            console.log(`Awaiting glhf.chat API response... (attempt: ${attempt})`);
+            try {
+                let completion = await this.openai.chat.completions.create(pack);
+                if (completion.choices[0].finish_reason === 'length') {
+                    throw new Error('Context length exceeded');
+                }
+                let res = completion.choices[0].message.content;
+                // If there's an open <think> tag without a corresponding </think>, retry.
+                if (res.includes("<think>") && !res.includes("</think>")) {
+                    console.warn("Partial <think> block detected. Re-generating...");
+                    continue;
+                }
+                // If there's a closing </think> tag but no opening <think>, prepend one.
+                if (res.includes("</think>") && !res.includes("<think>")) {
+                    res = "<think>" + res;
+                }
+                finalRes = res.replace(/<\|separator\|>/g, '*no response*');
+                break; // Valid response obtained.
+            } 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.error(err);
+                    finalRes = 'My brain disconnected, try again.';
+                    break;
+                }
+            }
+        }
+        if (finalRes === null) {
+            finalRes = "I thought too hard, sorry, try again";
+        }
+        return finalRes;
+    }
+
+    async embed(text) {
+        throw new Error('Embeddings are not supported by glhf.');
+    }
+}

package/src/models/gpt.js

@@ -0,0 +1,147 @@
+import OpenAIApi from 'openai';
+import { getKey, hasKey } from '../utils/keys.js';
+import { strictFormat } from '../utils/text.js';
+
+export class GPT {
+    static prefix = 'openai';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params;
+        this.url = url; // store so that we know whether a custom URL has been set
+
+        let config = {};
+        if (url)
+            config.baseURL = url;
+
+        if (hasKey('OPENAI_ORG_ID'))
+            config.organization = getKey('OPENAI_ORG_ID');
+
+        config.apiKey = getKey('OPENAI_API_KEY');
+
+        this.openai = new OpenAIApi(config);
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq='***') {
+        let messages = strictFormat(turns);
+        messages = messages.map(message => {
+            message.content += stop_seq;
+            return message;
+        });
+        let model = this.model_name || "gpt-4o-mini";
+
+        let res = null;
+
+        try {
+            console.log('Awaiting openai api response from model', model);
+            // if a custom URL is set, use chat.completions
+            // because custom "OpenAI-compatible" endpoints likely do not have responses endpoint
+            if (this.url) {
+                let messages = [{'role': 'system', 'content': systemMessage}].concat(turns);
+                messages = strictFormat(messages);
+                const pack = {
+                    model: model,
+                    messages,
+                    stop: stop_seq,
+                    ...(this.params || {})
+                };
+                if (model.includes('o1') || model.includes('o3') || model.includes('5')) {
+                    delete pack.stop;
+                }
+                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;
+            } 
+            // otherwise, use responses
+            else {
+                let messages = strictFormat(turns);
+                messages = messages.map(message => {
+                    message.content += stop_seq;
+                    return message;
+                });
+                const response = await this.openai.responses.create({
+                    model: model,
+                    instructions: systemMessage,
+                    input: messages,
+                    ...(this.params || {})
+                });
+                console.log('Received.');
+                res = response.output_text;
+                let stop_seq_index = res.indexOf(stop_seq);
+                res = stop_seq_index !== -1 ? res.slice(0, stop_seq_index) : res;
+            }
+        }
+        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: "input_text", text: systemMessage },
+                {
+                    type: "input_image",
+                    image_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;
+    }
+
+}
+
+const sendAudioRequest = async (text, model, voice, url) => {
+    const payload = {
+        model: model,
+        voice: voice,
+        input: text
+    }
+
+    let config = {};
+
+    if (url)
+        config.baseURL = url;
+
+    if (hasKey('OPENAI_ORG_ID'))
+        config.organization = getKey('OPENAI_ORG_ID');
+
+    config.apiKey = getKey('OPENAI_API_KEY');
+
+    const openai = new OpenAIApi(config);
+
+    const mp3 = await openai.audio.speech.create(payload);
+    const buffer = Buffer.from(await mp3.arrayBuffer());
+    const base64 = buffer.toString("base64");
+    return base64;
+}
+
+export const TTSConfig = {
+    sendAudioRequest: sendAudioRequest,
+    baseUrl: 'https://api.openai.com/v1',
+}

package/src/models/grok.js

@@ -0,0 +1,82 @@
+import OpenAIApi from 'openai';
+import { getKey } from '../utils/keys.js';
+
+// xAI doesn't supply a SDK for their models, but fully supports OpenAI and Anthropic SDKs
+export class Grok {
+    static prefix = 'xai';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.url = url;
+        this.params = params;
+
+        let config = {};
+        if (url)
+            config.baseURL = url;
+        else
+            config.baseURL = "https://api.x.ai/v1"
+
+        config.apiKey = getKey('XAI_API_KEY');
+
+        this.openai = new OpenAIApi(config);
+    }
+
+    async sendRequest(turns, systemMessage) {
+        let messages = [{'role': 'system', 'content': systemMessage}].concat(turns);
+
+        const pack = {
+            model: this.model_name || "grok-3-mini-latest",
+            messages,
+            ...(this.params || {})
+        };
+
+        let res = null;
+        try {
+            console.log('Awaiting xai api response...')
+            ///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);
+            } else if (err.message.includes('The model expects a single `text` element per message.')) {
+                console.log(err);
+                res = 'Vision is only supported by certain models.';
+            } else {
+                console.log(err);
+                res = 'My brain disconnected, try again.';
+            }
+        }
+        // sometimes outputs special token <|separator|>, just replace it
+        return res.replace(/<\|separator\|>/g, '*no response*');
+    }
+
+    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) {
+        throw new Error('Embeddings are not supported by Grok.');
+    }
+}
+
+
+

package/src/models/groq.js

@@ -0,0 +1,95 @@
+import Groq from 'groq-sdk'
+import { getKey } from '../utils/keys.js';
+
+// THIS API IS NOT TO BE CONFUSED WITH GROK!
+// Go to grok.js for that. :)
+
+// Umbrella class for everything under the sun... That GroqCloud provides, that is.
+export class GroqCloudAPI {
+    static prefix = 'groq';
+
+    constructor(model_name, url, params) {
+
+        this.model_name = model_name;
+        this.url = url;
+        this.params = params || {};
+
+        // Remove any mention of "tools" from params:
+        if (this.params.tools)
+            delete this.params.tools;
+        // This is just a bit of future-proofing in case we drag Mindcraft in that direction.
+
+        // I'm going to do a sneaky ReplicateAPI theft for a lot of this, aren't I?
+        if (this.url)
+            console.warn("Groq Cloud has no implementation for custom URLs. Ignoring provided URL.");
+
+        this.groq = new Groq({ apiKey: getKey('GROQCLOUD_API_KEY') });
+
+
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq = null) {
+        // Construct messages array
+        let messages = [{"role": "system", "content": systemMessage}].concat(turns);
+
+        let res = null;
+
+        try {
+            console.log("Awaiting Groq response...");
+
+            // Handle deprecated max_tokens parameter
+            if (this.params.max_tokens) {
+                console.warn("GROQCLOUD WARNING: A profile is using `max_tokens`. This is deprecated. Please move to `max_completion_tokens`.");
+                this.params.max_completion_tokens = this.params.max_tokens;
+                delete this.params.max_tokens;
+            }
+
+            if (!this.params.max_completion_tokens) {
+                this.params.max_completion_tokens = 4000;
+            }
+
+            let completion = await this.groq.chat.completions.create({
+                "messages": messages,
+                "model": this.model_name || "qwen/qwen3-32b",
+                "stream": false,
+                "stop": stop_seq,
+                ...(this.params || {})
+            });
+
+            res = completion.choices[0].message.content;
+
+            res = res.replace(/<think>[\s\S]*?<\/think>/g, '').trim();
+        }
+        catch(err) {
+            if (err.message.includes("content must be a string")) {
+                res = "Vision is only supported by certain models.";
+            } else {
+                res = "My brain disconnected, try again.";
+            }
+            console.log(err);
+        }
+        return res;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = messages.filter(message => message.role !== 'system');
+        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);
+    }
+
+    async embed(_) {
+        throw new Error('Embeddings are not supported by Groq.');
+    }
+}