llama-cpp-python-djs-bot/llamabot.js

import "dotenv/config.js";
import fetch from 'node-fetch';
import { emptyResponses } from './assets/emptyMessages.js';
import { resetResponses, userResetMessages } from './assets/resetMessages.js';
import { errorMessages, busyResponses } from './assets/errorMessages.js';
import cpuStat from 'cpu-stat';
import os from 'os';

import {
    Client,
    GatewayIntentBits,
    ActivityType,
    Partials
} from 'discord.js';

const client = new Client({
    intents: [
        GatewayIntentBits.DirectMessages,
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildModeration,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
    ],
    partials: [Partials.Channel],
});

// Grab ChannelIDs from the .env file
const channelIDs = process.env.CHANNEL_IDS.split(',');

const conversations = new Map();

function setBusy(userId, isBusy) {
    if (conversations.has(userId)) {
        conversations.get(userId).busy = isBusy;
    } else {
        conversations.set(userId, {
            busy: isBusy
        });
    }
}

function isAnyConversationBusy() {
    for (const conversation of conversations.values()) {
        if (conversation.busy) {
            setPresenceBusy()
            return true;
        }
    }
    return false;
}

function setPresenceBusy() {
    client.user.setPresence({
        activities: [{
            name: `Processing a Request`,
            type: ActivityType.Playing
        }],
        status: 'dnd',
    });
}

function setPresenceOnline() {
    client.user.setPresence({
        activities: [{
            name: `Ready for Request`,
            type: ActivityType.Playing
        }],
        status: 'online',
    });
}


client.once('ready', () => {
    console.log('Bot is ready.');
    setPresenceOnline()
});

client.on('messageCreate', async (message) => {

    async function sendRand(array) {
        const arrayChoice = array[Math.floor(Math.random() * array.length)];
        await message.channel.send(arrayChoice); // give a notification of reset using a human like response.
    }

    async function sendRandDM(array) {
        const arrayChoice = array[Math.floor(Math.random() * array.length)];
        await message.author.send(arrayChoice); // give a notification of reset using a human like response.
    }

    // Only respond in the specified channels
    if (!channelIDs.includes(message.channel.id)) {
        return;
    }

    if (message.author.bot) return; // Ignore messages from bots

    // Check if any conversation is busy
    if (isAnyConversationBusy()) {
        // Update bot presence to "Busy"
        setPresenceBusy()
        message.delete();
        sendRandDM(busyResponses);
        return;
    }
    const userID = message.author.id;
    let conversation = conversations.get(userID) || {
        messages: [],
        busy: false
    };

    if (conversation.messages.length === 0) {
        conversation.messages.push({
            role: 'user',
            content: ` ${process.env.INIT_PROMPT}`
        });
        conversation.messages.push({
            role: 'user',
            content: ` User name: ${message.author.username}.`
        });
        conversation.messages.push({
            role: 'assistant',
            content: ` Hello, ${message.author.username}, how may I help you?`
        });
    }

    if (message.content === '!reset' || message.content === '!r') {
        conversations.delete(userID); // Delete user's conversation map if they request reset
        sendRand(userResetMessages)
        return;
    }

    // Append user message to conversation history
    conversation.messages.push({
        role: 'user',
        content: ` ${message.cleanContent}`
    });

    try {
        setPresenceBusy()
        setBusy(message.author.id, true);

        const response = await generateResponse(conversation, message);

        // Append bot message to conversation history
        conversation.messages.push({
            role: 'assistant',
            content: response
        });

        if (response && response.trim()) {
            // Send response to user if it's not empty
            const limit = 1980;

            // if we are over the discord char limit we need chunks...
            if (response.length > limit) {
              const chunks = response.match(new RegExp(`.{1,${limit}}`, "g"));
              for (let i = 0; i < chunks.length; i++) {
                setTimeout(() => {
                  message.channel.send(chunks[i]);
                }, i * 3000); // delay of 3 seconds between each chunk to save on API requests
              }
            } else {
              // We are good to go, send the response
              await message.channel.send(response);
            }
            
            setPresenceOnline()
            setBusy(message.author.id, false);
        } else {
            // Handle empty response here
            sendRand(emptyResponses)
            conversations.delete(userID); // Delete user's conversation map if they request reset
            sendRand(resetResponses)
            setPresenceOnline()
            conversation.busy = false;
        }
        conversations.set(userID, conversation); // Update user's conversation map in memory
    } catch (err) {
        console.error(err);
        sendRand(errorMessages)
    } finally {
        setPresenceOnline()
        setBusy(message.author.id, false);
    }
});


async function generateResponse(conversation, message) {
    const controller = new AbortController();
    const timeout = setTimeout(() => {
        controller.abort();
    }, 900000);

    const messagesCopy = [...conversation.messages]; // create a copy of the messages array

    let botMessage; // define a variable to hold the message object
    let time = 0
    // define a function that shows the system load percentage and updates the message
    const showSystemLoad = async () => {
        time = time + 7;
        cpuStat.usagePercent(function(err, percent, seconds) {
          if (err) {
            return console.log(err);
          }
      
          const systemLoad = percent;
          const freeMemory = os.freemem() / 1024 / 1024 / 1024;
          const totalMemory = os.totalmem() / 1024 / 1024 / 1024;
          const usedMemory = totalMemory - freeMemory;
      
          const embedData = {
            color: 0x0099ff,
            title: 'Thinking...',
            fields: [
              {
                name: 'System Load',
                value: `${systemLoad.toFixed(2)}%`,
              },
              {
                name: 'Memory Usage',
                value: `${usedMemory.toFixed(2)} GB / ${totalMemory.toFixed(2)} GB`,
              },
              {
                name: 'Time',
                value: `~${time} seconds.`,
              },
            ],
          };
      
          // if the message object doesn't exist, create it
          if (!botMessage) {
            (async () => {
              botMessage = await message.channel.send({ embeds: [embedData] });
            })();
          } else {
            botMessage.edit({ embeds: [embedData] }); // otherwise, update the message
          }
        });
      };

    // call the function initially
    await showSystemLoad();

    // refresh the system load percentage and update the message every 7 seconds
    const refreshInterval = setInterval(showSystemLoad, 7000);

    try {
        const response = await fetch(`http://${process.env.ROOT_IP}:${process.env.ROOT_PORT}/v1/chat/completions`, {
            method: 'POST',
            headers: {
              'accept': 'application/json',
              'Content-Type': 'application/json'
            },
            body: JSON.stringify({
              messages: messagesCopy,
              max_tokens: Number(process.env.MAX_TOKENS) // add the max_tokens parameter here
            }),
            signal: controller.signal
          });

        const responseData = await response.json();
        console.log(JSON.stringify(responseData));
        const choice = responseData.choices[0];

        const responseText = choice.message.content;

        // clear the interval, replace the "please wait" message with the response, and update the message
        clearInterval(refreshInterval);
        console.log(responseText);
        botMessage.delete()

        return responseText;

    } catch (err) {
        throw err;
    } finally {
        clearTimeout(timeout);
        time = 0
    }
}

client.login(process.env.THE_TOKEN); // Replace with your bot token