added persistence in chat endpoint

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "discord-ollama",
-  "version": "0.0.1",
+  "version": "0.1.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "discord-ollama",
-      "version": "0.0.1",
+      "version": "0.1.1",
       "license": "ISC",
       "dependencies": {
         "axios": "^1.6.2",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-ollama",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Ollama Integration into discord",
   "main": "dist/index.js",
   "exports": "./dist/index.js",

src/client.ts

@@ -14,7 +14,14 @@ const client = new Client({
     ]
 });
 
-registerEvents(client, Events)
+const messageHistory = [
+    {
+        role: 'assistant',
+        content: 'My name is Ollama GU.'
+    }
+]
+
+registerEvents(client, Events, messageHistory)
 
 // Try to log in the client
 client.login(Keys.clientToken)

src/events/messageCreate.ts

@@ -4,7 +4,7 @@ import Axios from 'axios'
 /*
  * Max Message length for free users is 2000 characters (bot or not).
  */
-export default event(Events.MessageCreate, ({ log }, message) => {
+export default event(Events.MessageCreate, ({ log, msgHist }, message) => {
     log(`Message created \"${message.content}\" from ${message.author.tag}.`)
 
     // Hard-coded channel to test output there only, in our case "ollama-endpoint"
@@ -13,20 +13,32 @@ export default event(Events.MessageCreate, ({ log }, message) => {
     // Do not respond if bot talks in the chat
     if (message.author.tag === message.client.user.tag) return
 
+    // push user response
+    msgHist.push({
+        role: 'user',
+        content: message.content
+    })
+
     // Reply with something to prompt that ollama is working
-    message.reply("Generating Response...").then(sentMessage => {
+    message.reply("Generating Response . . .").then(sentMessage => {
         // Request made to API
         const request = async () => {
             try {
                 // change this when using an actual hosted server or use ollama.js
-                const response = await Axios.post('http://127.0.0.1:11434/api/generate', {
+                const response = await Axios.post('http://127.0.0.1:11434/api/chat', {
                     model: 'llama2',
-                    prompt: message.content,
+                    messages: msgHist,
                     stream: false
                 })
                 log(response.data)
     
-                sentMessage.edit(response.data.response)
+                sentMessage.edit(response.data.message.content)
+
+                // push bot response
+                msgHist.push({
+                    role: 'assistant',
+                    content: response.data.message.content
+                })
             } catch (error) {
                 log(error)
             }

src/utils/events.ts

@@ -1,43 +1,44 @@
-import type { ClientEvents, Awaitable, Client } from 'discord.js';
+import type { ClientEvents, Awaitable, Client } from 'discord.js'
 
 // Export events through here to reduce amount of imports
-export { Events } from 'discord.js';
+export { Events } from 'discord.js'
 
-export type LogMethod = (...args: unknown[]) => void;
+export type LogMethod = (...args: unknown[]) => void
-export type EventKeys = keyof ClientEvents; // only wants keys of ClientEvents object
+export type EventKeys = keyof ClientEvents // only wants keys of ClientEvents object
 
 // Event properties
 export interface EventProps {
-    client: Client;
+    client: Client
-    log: LogMethod;
+    log: LogMethod
+    msgHist: { role: string, content: string }[]
 }
 export type EventCallback<T extends EventKeys> = (
     props: EventProps,
     ...args: ClientEvents[T]
-) => Awaitable<unknown>; // Method can be synchronous or async, unknown so we can return anything
+) => Awaitable<unknown> // Method can be synchronous or async, unknown so we can return anything
 
 // Event interface
 export interface Event<T extends EventKeys = EventKeys> {
-    key: T;
+    key: T
-    callback: EventCallback<T>;
+    callback: EventCallback<T>
 }
 
 export function event<T extends EventKeys>(key: T, callback: EventCallback<T>): Event<T> {
-    return { key, callback };
+    return { key, callback }
 }
 
-export function registerEvents(client: Client, events: Event[]): void {
+export function registerEvents(client: Client, events: Event[], msgHist: { role: string, content: string }[]): void {
     for (const { key, callback } of events) {
         client.on(key, (...args) => {
             // Create a new log method for this event
-            const log = console.log.bind(console, `[Event: ${key}]`);
+            const log = console.log.bind(console, `[Event: ${key}]`)
 
             // Handle Errors, call callback, log errors as needed
             try {
-                callback({ client, log }, ...args);
+                callback({ client, log, msgHist }, ...args)
             } catch (error) {
-                log('[Uncaught Error]', error);
+                log('[Uncaught Error]', error)
             }
-        });
+        })
     }
 }