alex/discord-aidolls
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

multi bot partly working; bots won't shut up though
Some checks failed
Builds / Discord-Node-Build (push) Has been cancelled
Details
Builds / Discord-Ollama-Container-Build (push) Has been cancelled
Details
Coverage / Discord-Node-Coverage (push) Has been cancelled
Details
Deploy / Deploy-Application (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Alex
2025-05-21 21:46:47 -04:00
parent 9ffe94ad09
commit d3fd88da04
4 changed files with 276 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
src/events/messageCreate.ts
View File

@@ -1,13 +1,11 @@
import { TextChannel } from 'discord.js'
import { event, Events, normalMessage, UserMessage, clean } from '../utils/index.js'
import {
getChannelInfo, getServerConfig, getUserConfig, openChannelInfo,
openConfig, UserConfig, getAttachmentData, getTextFileAttachmentData
} from '../utils/index.js'
import { TextChannel, Attachment, Message } from 'discord.js'
import { event, Events, UserMessage, clean, getServerConfig, getTextFileAttachmentData, getAttachmentData } from '../utils/index.js'
import { redis } from '../client.js'
import fs from 'fs/promises'
import path from 'path'
import { fileURLToPath } from 'url'
import { Ollama } from 'ollama'
import { Queue } from '../queues/queue.js'
// Define interface for model response to improve type safety
interface ModelResponse {
@@ -22,13 +20,23 @@ interface ModelResponse {
}
}
// Define interface for user config
interface UserConfig {
options: {
'message-style': boolean
'switch-model': string
'modify-capacity': number
'message-stream'?: boolean
}
}
/**
* Max Message length for free users is 2000 characters (bot or not).
* Bot supports infinite lengths for normal messages.
*
* @param message the message received from the channel
*/
export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client, defaultModel }, message) => {
export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client, defaultModel }: { log: (msg: string) => void, msgHist: Queue<UserMessage>, ollama: Ollama, client: any, defaultModel: string }, message: Message) => {
const clientId = client.user!.id
let cleanedMessage = clean(message.content, clientId)
log(`Message "${cleanedMessage}" from ${message.author.tag} in channel/thread ${message.channelId}.`)
@@ -38,7 +46,10 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
const isMentioned = message.mentions.has(clientId)
const isCommand = message.content.startsWith('/')
const randomChance = Math.random() < 0.1 // 10% chance for non-directed or bot messages
if (!isMentioned && !isBotMessage && (isCommand || !randomChance)) return
if (!isMentioned && !isBotMessage && (isCommand || !randomChance)) {
log(`Skipping message: isMentioned=${isMentioned}, isBotMessage=${isBotMessage}, isCommand=${isCommand}, randomChance=${randomChance}`)
return
}
// Check if message is a bot response to avoid loops
const isBotResponseKey = `message:${message.id}:is_bot_response`
@@ -50,20 +61,50 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
}
}
// Check cooldown for bot-to-bot responses
// Check if last response was to a bot and require user message
const lastResponseToBotKey = `bot:${clientId}:last_response_to_bot`
let shouldRespond = true
if (isBotMessage) {
try {
const lastResponseToBot = await redis.get(lastResponseToBotKey)
if (lastResponseToBot === 'true') {
log(`Skipping bot message: Last response was to a bot. Waiting for user message.`)
return
}
} catch (error) {
log(`Failed to check last response to bot: ${error}`)
}
}
// Check cooldown for bot-to-bot responses only if probability check passes
const botResponseCooldownKey = `bot:${clientId}:last_bot_response`
const cooldownPeriod = 60 // 60 seconds cooldown
if (isBotMessage) {
if (isBotMessage && randomChance) {
log(`Bot message probability check passed (10% chance). Checking cooldown.`)
try {
const lastResponseTime = await redis.get(botResponseCooldownKey)
const currentTime = Math.floor(Date.now() / 1000)
if (lastResponseTime && (currentTime - parseInt(lastResponseTime)) < cooldownPeriod) {
log(`Bot ${clientId} is in cooldown for bot-to-bot response. Skipping.`)
return
shouldRespond = false
}
} catch (error) {
log(`Failed to check bot response cooldown: ${error}`)
}
} else if (isBotMessage) {
log(`Bot message probability check failed (10% chance). Skipping cooldown check.`)
}
if (!shouldRespond) return
// Reset last_response_to_bot flag if this is a user message
if (!isBotMessage) {
try {
await redis.set(lastResponseToBotKey, 'false')
log(`Reset last_response_to_bot flag for bot ${clientId}`)
} catch (error) {
log(`Failed to reset last_response_to_bot flag: ${error}`)
}
}
// Log response trigger
@@ -84,7 +125,7 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
await new Promise((resolve, reject) => {
getServerConfig(`${message.guildId}-config.json`, (config) => {
if (config === undefined) {
openConfig(`${message.guildId}-config.json`, 'toggle-chat', true)
redis.set(`server:${message.guildId}:config`, JSON.stringify({ options: { 'toggle-chat': true } }))
reject(new Error('Failed to locate or create Server Preferences\n\nPlease try chatting again...'))
} else if (!config.options['toggle-chat']) {
reject(new Error('Admin(s) have disabled chat features.\n\nPlease contact your server\'s admin(s).'))
@@ -105,18 +146,30 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
}
}
// Retrieve User Preferences
// Retrieve User Preferences from Redis
attempt = 0
let userConfig: UserConfig | undefined
const userConfigKey = `user:${message.author.username}:config`
while (attempt < maxRetries) {
try {
userConfig = await new Promise((resolve, reject) => {
getUserConfig(`${message.author.username}-config.json`, (config) => {
if (config === undefined) {
openConfig(`${message.author.username}-config.json`, 'message-style', false)
openConfig(`${message.author.username}-config.json`, 'switch-model', defaultModel)
openConfig(`${message.author.username}-config.json`, 'modify-capacity', 50)
reject(new Error('No User Preferences is set up.\n\nCreating preferences file with defaults.\nPlease try chatting again.'))
redis.get(userConfigKey).then(configRaw => {
let config: UserConfig | undefined
if (configRaw) {
config = JSON.parse(configRaw)
}
if (!config) {
const defaultConfig: UserConfig = {
options: {
'message-style': false,
'switch-model': defaultModel,
'modify-capacity': 50,
'message-stream': false
}
}
redis.set(userConfigKey, JSON.stringify(defaultConfig))
log(`Created default config for ${message.author.username}`)
reject(new Error('No User Preferences is set up.\n\nCreating preferences with defaults.\nPlease try chatting again.'))
return
}
@@ -128,14 +181,14 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
msgHist.capacity = 50
}
shouldStream = config.options['message-stream'] as boolean || false
shouldStream = config.options['message-stream'] || false
if (typeof config.options['switch-model'] !== 'string') {
reject(new Error(`No Model was set. Please set a model by running \`/switch-model <model of choice>\`.\n\nIf you do not have any models. Run \`/pull-model <model name>\`.`))
}
resolve(config)
})
}).catch(err => reject(err))
})
break
} catch (error) {
@@ -149,35 +202,21 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
}
}
// Retrieve Channel Messages with Retry
// Retrieve Channel Messages from Redis
let chatMessages: UserMessage[] = []
attempt = 0
while (attempt < maxRetries) {
try {
chatMessages = await new Promise((resolve, reject) => {
getChannelInfo(`${message.channelId}-${message.author.username}.json`, (channelInfo) => {
if (channelInfo?.messages) {
resolve(channelInfo.messages)
} else {
log(`Channel/Thread ${message.channelId}-${message.author.username} does not exist. Creating file...`)
openChannelInfo(message.channelId, message.channel as TextChannel, message.author.tag)
reject(new Error('Channel file created, retrying...'))
}
})
})
break
} catch (error) {
++attempt
if (attempt < maxRetries) {
log(`Attempt ${attempt} failed for Channel Info. Retrying in 500ms...`)
await new Promise(ret => setTimeout(ret, 500))
} else {
log(`Failed to retrieve or create channel history after ${maxRetries} attempts. Using empty history.`)
chatMessages = []
openChannelInfo(message.channelId, message.channel as TextChannel, message.author.tag, [])
break
}
const channelHistoryKey = `channel:${message.channelId}:${message.author.username}:history`
try {
const historyRaw = await redis.get(channelHistoryKey)
if (historyRaw) {
chatMessages = JSON.parse(historyRaw)
log(`Retrieved ${chatMessages.length} messages from Redis for ${channelHistoryKey}`)
} else {
log(`No history found for ${channelHistoryKey}. Initializing empty history.`)
chatMessages = []
}
} catch (error) {
log(`Failed to retrieve channel history from Redis: ${error}. Using empty history.`)
chatMessages = []
}
if (!userConfig) {
@@ -359,24 +398,30 @@ export default event(Events.MessageCreate, async ({ log, msgHist, ollama, client
try {
await redis.set(`message:${replyMessage.id}:is_bot_response`, 'true', { EX: 3600 }) // 1 hour TTL
log(`Marked message ${replyMessage.id} as bot response`)
// Set flag indicating last response was to a bot
await redis.set(lastResponseToBotKey, 'true')
log(`Set last_response_to_bot flag for bot ${clientId}`)
} catch (error) {
log(`Failed to mark message as bot response: ${error}`)
log(`Failed to mark message as bot response or set last_response_to_bot flag: ${error}`)
}
}
// Update message history
// Update message history in Redis
while (msgHist.size() >= msgHist.capacity) msgHist.dequeue()
msgHist.enqueue({
role: 'assistant',
content: reply,
images: messageAttachment || []
})
// Save updated history
openChannelInfo(message.channelId, message.channel as TextChannel, message.author.tag, msgHist.getItems())
try {
await redis.set(channelHistoryKey, JSON.stringify(msgHist.getItems()))
log(`Saved ${msgHist.size()} messages to Redis for ${channelHistoryKey}`)
} catch (error) {
log(`Failed to save channel history to Redis: ${error}`)
}
// Update cooldown timestamp for bot-to-bot response
if (isBotMessage && jsonResponse.status === 'success') {
if (isBotMessage && jsonResponse.status === 'success' && randomChance) {
try {
const currentTime = Math.floor(Date.now() / 1000)
await redis.set(botResponseCooldownKey, currentTime.toString(), { EX: cooldownPeriod })

8
src/utils/events.ts
View File

@@ -21,7 +21,7 @@ export type ChatParams = {
}
/**
* Format for the messages to be stored when communicating when the bot
* Format for the messages to be stored when communicating with the bot
* @param role either assistant, user, or system
* @param content string of the message the user or assistant provided
* @param images array of images that the user or assistant provided
@@ -38,7 +38,7 @@ export interface EventProps {
log: LogMethod,
msgHist: Queue<UserMessage>,
ollama: Ollama,
defaultModel: String
defaultModel: string
}
/**
@@ -79,7 +79,7 @@ export function registerEvents(
events: Event[],
msgHist: Queue<UserMessage>,
ollama: Ollama,
defaultModel: String
defaultModel: string
): void {
for (const { key, callback } of events) {
client.on(key, (...args) => {
@@ -94,4 +94,4 @@ export function registerEvents(
}
})
}
}
}