2023-04-09 12:07:32 -04:00
const Discord = require ( 'discord.js' ) ;
const fetch = require ( 'node-fetch' ) ;
2023-04-09 19:45:06 -04:00
const emptyResponses = require ( './assets/emptyMessages.js' ) ;
const resetResponses = require ( './assets/resetMessages.js' ) ;
const errorMessages = require ( './assets/errorMessages.js' ) ;
2023-04-09 12:07:32 -04:00
require ( 'dotenv' ) . config ( )
2023-04-09 12:31:48 -04:00
// hi
2023-04-09 19:49:51 -04:00
const {
Client ,
GatewayIntentBits ,
ActivityType ,
Partials
} = require ( 'discord.js' ) ;
2023-04-09 12:07:32 -04:00
const client = new Client ( {
2023-04-09 19:49:51 -04:00
intents : [
GatewayIntentBits . DirectMessages ,
GatewayIntentBits . Guilds ,
GatewayIntentBits . GuildBans ,
GatewayIntentBits . GuildMessages ,
GatewayIntentBits . MessageContent ,
] ,
partials : [ Partials . Channel ] ,
2023-04-09 12:07:32 -04:00
} ) ;
const channelID = '1094494101631680653' ; // Replace with your channel ID
const channelID2 = '1094628334727614605' ; // Replace with your channel ID
const conversations = new Map ( ) ;
client . once ( 'ready' , ( ) => {
2023-04-09 19:49:51 -04:00
console . log ( 'Bot is ready.' ) ;
client . user . setPresence ( {
activities : [ {
name : ` AI ` ,
type : ActivityType . Playing
} ] ,
status : 'dnd' ,
} ) ;
2023-04-09 12:07:32 -04:00
} ) ;
client . on ( 'messageCreate' , async ( message ) => {
2023-04-09 19:49:51 -04:00
// Only respond in the specified channels
if ( message . channel . id !== channelID && message . channel . id !== channelID2 ) {
return ;
}
if ( message . author . bot ) return ; // Ignore messages from bots
2023-04-09 12:07:32 -04:00
2023-04-09 19:49:51 -04:00
if ( conversations . get ( message . author . id ) ? . busy ) {
message . delete ( )
await message . author . send ( "I'm currently busy with another process. Please try again later." ) ;
return ;
}
2023-04-09 12:07:32 -04:00
2023-04-09 19:49:51 -04:00
const userID = message . author . id ;
let conversation = conversations . get ( userID ) || {
messages : [ ] ,
busy : false
} ;
if ( conversation . messages . length === 0 ) {
conversation . messages . push ( {
role : 'user' ,
content : ` You are the smartest AI and help with anything I ask. You are great at coding! When giving a list always use one line per item. My name is ${ message . author . username } . `
} ) ;
conversation . messages . push ( {
role : 'user' ,
content : ` My name is ${ message . author . username } . `
} ) ;
conversation . messages . push ( {
role : 'assistant' ,
content : ` Hello, ${ message . author . username } , how may I help you? `
} ) ;
conversation . messages . push ( {
role : 'user' ,
content : message . cleanContent
} ) ;
2023-04-09 12:07:32 -04:00
2023-04-09 19:49:51 -04:00
} else {
// Append user message to conversation history
conversation . messages . push ( {
role : 'user' ,
content : message . cleanContent
} ) ;
}
if ( message . content === '!reset' || message . content === '!r' ) {
conversations . delete ( userID ) ; // Delete user's conversation map if they request reset
await message . channel . send ( 'Conversation reset.' ) ;
return ;
}
2023-04-09 12:07:32 -04:00
2023-04-09 19:45:06 -04:00
// Append user message to conversation history
2023-04-09 19:49:51 -04:00
conversation . messages . push ( {
role : 'user' ,
content : message . cleanContent
} ) ;
2023-04-09 12:07:32 -04:00
2023-04-09 19:49:51 -04:00
try {
conversation . busy = true ;
const response = await generateResponse ( conversation ) ;
// 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
await message . channel . send ( response ) ;
conversation . busy = false ;
} else {
// Handle empty response here
const randomResponse = emptyResponses [ Math . floor ( Math . random ( ) * emptyResponses . length ) ] ;
// We had an empty response, create a new memory map for sanity.
await message . channel . send ( randomResponse ) ; // give the user a human like reponse about the error
conversations . delete ( userID ) ; // Delete user's conversation map if they request reset
const resetMessage = resetResponses [ Math . floor ( Math . random ( ) * resetResponses . length ) ] ;
await message . channel . send ( resetMessage ) ; // give a notification of reset using a human like response.
conversation . busy = false ;
}
conversations . set ( userID , conversation ) ; // Update user's conversation map in memory
} catch ( err ) {
console . error ( err ) ;
const errorMessage = errorMessages [ Math . floor ( Math . random ( ) * errorMessages . length ) ] ;
await message . channel . send ( errorMessage ) ; // give a notification of reset using a human like response. } finally {
conversation . busy = false ;
2023-04-09 19:10:48 -04:00
}
2023-04-09 12:07:32 -04:00
} ) ;
async function generateResponse ( conversation ) {
2023-04-09 19:49:51 -04:00
const controller = new AbortController ( ) ;
const timeout = setTimeout ( ( ) => {
controller . abort ( ) ;
} , 900000 ) ;
try {
const response = await fetch ( 'http://192.168.0.15/v1/chat/completions' , {
method : 'POST' ,
headers : {
'accept' : 'application/json' ,
'Content-Type' : 'application/json'
} ,
body : JSON . stringify ( {
messages : conversation . messages
} ) ,
signal : controller . signal
} ) ;
const responseData = await response . json ( ) ;
const choice = responseData . choices [ 0 ] ;
// Remove "user None:" and any text after it from the response
const responseText = choice . message . content . trim ( ) ;
const startIndex = responseText . indexOf ( 'user None:' ) ;
const sanitizedResponse = startIndex === - 1 ? responseText : responseText . substring ( 0 , startIndex ) ;
return sanitizedResponse ;
} catch ( err ) {
console . error ( err ) ;
return 'Oops, something went wrong!' ;
} finally {
clearTimeout ( timeout ) ;
}
2023-04-09 12:07:32 -04:00
}
2023-04-09 19:49:51 -04:00
client . login ( process . env . THE _TOKEN ) ; // Replace with your bot token