ircgpt/index.js

#!/usr/bin/env node
//IRC bot that responds to !chat, queries the chatgpt api, and prints the response line by line
const irc = require('irc');
const axios = require('axios');
const config = require('./config.json');
const fs = require('fs');

const seed_messages = [{role: 'system', content: 'You are a dungeon master, DMing a game for your friends. The setting is Left World, a dreamscape where not everything is as it seems. Let user introduce their characters and give them scenarios to interact with. Feel free to introduce NPCs, but do not make moves for the characters. If user introduces another character, keep the story going where you left off as if that new character just arrived.'}];
// context is a list of strings that are used to seed the chatgpt api and it's responses
class Context {

    currentLine = '';
    currentResponse = '';

    constructor(messages = default_messages) {
	this.messages = messages;
    }

    add_user_prompt(message) {
        this.messages.push({ role: 'user', content: message });
    }

    add_assistant_message(message) {
        this.messages.push({ role: 'assistant', content: message });
    }

    append_to_line(message) {
        this.currentLine += message;
    }

    end_line() {
	const the_line = this.currentLine;
        this.currentResponse += `${the_line}\n\n`;
	this.currentLine = '';
        return the_line;
    }

    finish_current_response() {
        this.add_assistant_message(this.currentResponse);
	const theLine = this.currentLine;
        this.currentResponse = '';
	this.currentLine = '';
	this.save_history();
        return theLine;
    }

    save_history() {
	const prettyData = JSON.stringify(this.messages, null, 2);

	fs.writeFileSync('./messages.json', prettyData);
    }

    is_response_in_progress() {
        return this.currentResponse !== '' || this.currentLine !== '';
    }

    peek_line() {
	    return this.currentLine;
    }

    clear() {
        this.messages = [];
        this.currentResponse = '';
	this.currentLine = '';
    }
}

const savedMessages = require('./messages.json');
const context = new Context(savedMessages);

const client = new irc.Client(config.server, config.nick, {
    channels: config.channels,
});

// listen for messages that start with !chat and call the chatgpt api with a callback that prints the response line by line
client.addListener('message', async (from, to, message) => {
    
    is_chat_cmd = message.startsWith('!chat');
    is_cont_cmd = message.startsWith('!cont');
    if (is_chat_cmd || is_cont_cmd) {
        if(context.is_response_in_progress()) { return; }
        const query = message.slice(6);
        chatgpt(query, (line) => {
            client.say(to, line);
        });
    }
});

// function that calls the chatgpt streaming api (with server send events) and calls the callback function for each line
async function chatgpt(query, callback) {
    // a very primitive mutex to prevent multiple calls to the api at once
    if(context.is_response_in_progress()) { return; }
    context.add_user_prompt(query);
    const apiUrl = 'https://api.openai.com/v1/chat/completions';
    let response = null;
    try {
	    response = await axios.post(apiUrl, {
		    messages: context.messages,
		    model: 'gpt-3.5-turbo',
		    stream: true,
	    }, {
		    headers: {
			    Authorization: `Bearer ${config.openaiApiKey}`,
			    'Content-Type': 'application/json',
		    },
		    responseType: 'stream',
	    });
    } catch(error) {
	    if (error.response) {
		    // The request was made and the server responded with a status code
		    // that falls out of the range of 2xx
		    console.log(error.toJSON());
	    } else if (error.request) {
		    // The request was made but no response was received
		    // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
		    // http.ClientRequest in node.js
		    console.log(error.request);
	    } else {
		    // Something happened in setting up the request that triggered an Error
		    console.log('Error', error.message);
	    }
	    return;
    }

    response.data.on('data', (event) => {
        let data = event.toString();
        let parts = data.split('\n');
        // parse if starts with data:
        for(part of parts) {
            console.log(part);
            if(part === 'data: [DONE]') {
                callback(context.finish_current_response());
            } else if(part.startsWith('data: ')) {
                let jsonString = part.slice(part.indexOf('{'), part.lastIndexOf('}') + 1);
                try {
                    let json = JSON.parse(jsonString);
                    let chunk = json.choices[0].delta.content;
                    if (!chunk) {
                        continue;
                    }
                    //split the chunk into lines leaving the delimiter in the array
                    const lines = chunk.split(/\r?\n/); // split by new lines

                    let hasStartNewline = chunk.startsWith("\n");
                    let hasEndNewline = chunk.endsWith("\n");

                    if(hasStartNewline) {
                        callback(context.end_line())
                    }
                    
                    for (let i = 0; i < lines.length - 1; i++) {
                        context.append_to_line(lines[i]);
                        callback(context.end_line());
                    }

                    context.append_to_line(lines[lines.length - 1]);

                    if(hasEndNewline) {
                        callback(context.end_line());
                    }

                    if (context.peek_line().length > 400) {
                        callback(context.end_line());
                    }
                } catch (e) {
                    console.log(e);
                    console.log(part);
                }
            }
        }
    });
}