Linting

discordBot/modules/gptHandler.mjs

@@ -1,122 +1,117 @@
 import { DebugBuilder } from "../../modules/debugger.mjs";
 const log = new DebugBuilder("server", "discordBot.modules.gptHandler");
-import dotenv from 'dotenv';
+import dotenv from "dotenv";
 dotenv.config();
 
-import { OpenAI } from 'openai';
-import { EventEmitter } from 'events';
+import { OpenAI } from "openai";
+import { EventEmitter } from "events";
 
 const openai = new OpenAI(process.env.OPENAI_API_KEY);
 
 const assistant = await openai.beta.assistants.create({
-    name: "Emmelia",
-    instructions: process.env.DRB_SERVER_INITIAL_PROMPT,
-    model: "gpt-4o",    
+  name: "Emmelia",
+  instructions: process.env.DRB_SERVER_INITIAL_PROMPT,
+  model: "gpt-4o",
 });
 
 class EventHandler extends EventEmitter {
-    constructor(client) {
-        super();
-        this.client = client;
-    }
+  constructor(client) {
+    super();
+    this.client = client;
+  }
 
-    async onEvent(event) {
-        try {
-            console.log(event);
-            // Retrieve events that are denoted with 'requires_action'
-            // since these will have our tool_calls
-            if (event.event === "thread.run.requires_action") {
-                await this.handleRequiresAction(
-                    event.data,
-                    event.data.id,
-                    event.data.thread_id,
-                );
-            }
-        } catch (error) {
-            console.error("Error handling event:", error);
-        }
+  async onEvent(event) {
+    try {
+      console.log(event);
+      // Retrieve events that are denoted with 'requires_action'
+      // since these will have our tool_calls
+      if (event.event === "thread.run.requires_action") {
+        await this.handleRequiresAction(
+          event.data,
+          event.data.id,
+          event.data.thread_id,
+        );
+      }
+    } catch (error) {
+      console.error("Error handling event:", error);
     }
+  }
 
-    async handleRequiresAction(data, runId, threadId) {
-        try {
-            const toolOutputs =
-                data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
-                    // Call the function
-                    switch (toolCall.function.name) {
-                        case "getCurrentTemperature": return {
-                            tool_call_id: toolCall.id,
-                            output: "57",
-                        };
-                    }
-                });
-            // Submit all the tool outputs at the same time
-            await this.submitToolOutputs(toolOutputs, runId, threadId);
-        } catch (error) {
-            console.error("Error processing required action:", error);
-        }
+  async handleRequiresAction(data, runId, threadId) {
+    try {
+      const toolOutputs =
+        data.required_action.submit_tool_outputs.tool_calls.map((toolCall) => {
+          // Call the function
+          switch (toolCall.function.name) {
+            case "getCurrentTemperature":
+              return {
+                tool_call_id: toolCall.id,
+                output: "57",
+              };
+          }
+        });
+      // Submit all the tool outputs at the same time
+      await this.submitToolOutputs(toolOutputs, runId, threadId);
+    } catch (error) {
+      console.error("Error processing required action:", error);
     }
+  }
 
-    async submitToolOutputs(toolOutputs, runId, threadId) {
-        try {
-            // Use the submitToolOutputsStream helper
-            const stream = this.client.beta.threads.runs.submitToolOutputsStream(
-                threadId,
-                runId,
-                { tool_outputs: toolOutputs },
-            );
-            for await (const event of stream) {
-                this.emit("event", event);
-            }
-        } catch (error) {
-            console.error("Error submitting tool outputs:", error);
-        }
+  async submitToolOutputs(toolOutputs, runId, threadId) {
+    try {
+      // Use the submitToolOutputsStream helper
+      const stream = this.client.beta.threads.runs.submitToolOutputsStream(
+        threadId,
+        runId,
+        { tool_outputs: toolOutputs },
+      );
+      for await (const event of stream) {
+        this.emit("event", event);
+      }
+    } catch (error) {
+      console.error("Error submitting tool outputs:", error);
     }
+  }
 }
 
 const eventHandler = new EventHandler(openai);
 eventHandler.on("event", eventHandler.onEvent.bind(eventHandler));
 
 export const gptHandler = async (additionalMessages) => {
-    const thread = await openai.beta.threads.create();
+  const thread = await openai.beta.threads.create();
 
-    // Add the additional messages to the conversation
-    for (const msgObj of additionalMessages) {
-        await openai.beta.threads.messages.create(
-            thread.id,
-            msgObj
-        );
+  // Add the additional messages to the conversation
+  for (const msgObj of additionalMessages) {
+    await openai.beta.threads.messages.create(thread.id, msgObj);
+  }
+
+  log.DEBUG("AI Conversation:", thread);
+
+  // Run the thread to get a response
+  try {
+    const stream = await openai.beta.threads.runs.stream(
+      thread.id,
+      { assistant_id: assistant.id },
+      eventHandler,
+    );
+
+    for await (const event of stream) {
+      eventHandler.emit("event", event);
     }
 
-    log.DEBUG("AI Conversation:", thread);
+    let response;
+    const messages = await openai.beta.threads.messages.list(thread.id);
+    response = messages.data[0].content[0].text.value;
 
-    // Run the thread to get a response
-    try {
-        const stream = await openai.beta.threads.runs.stream(
-            thread.id,
-            { assistant_id: assistant.id },
-            eventHandler,
-        );
+    log.DEBUG("AI Response:", response);
 
-        for await (const event of stream) {
-            eventHandler.emit("event", event);
-        }
-
-        let response;
-        const messages = await openai.beta.threads.messages.list(
-            thread.id
-        );
-        response = messages.data[0].content[0].text.value;
-
-        log.DEBUG("AI Response:", response);
-
-        if (!response) {
-            return false;
-        }
-
-        return response;
-
-    } catch (error) {
-        console.error('Error generating response:', error);
-        return false;
+    if (!response) {
+      return false;
     }
-}
+
+    return response;
+  } catch (error) {
+    console.error("Error generating response:", error);
+    return false;
+  }
+};