Resolve merge conflicts

Let's merge this because I am getting tired of resolving conflicts for
people to not review.

Author: christolis

CLA.md

@@ -115,8 +115,6 @@ IF THE DISCLAIMER AND DAMAGE WAIVER MENTIONED IN SECTION 5. AND SECTION 6. CANNO
 
 ### Us
 
-Name: Daniel Tischner (aka Zabuzard, acting on behalf of Together Java)
-
 Organization: https://github.com/Together-Java
 
 Contact: https://discord.com/invite/XXFUXzK

application/build.gradle

@@ -57,7 +57,7 @@ dependencies {
 
     implementation 'io.mikael:urlbuilder:2.0.9'
 
-    implementation 'org.jsoup:jsoup:1.21.1'
+    implementation 'org.jsoup:jsoup:1.22.1'
 
     implementation 'org.scilab.forge:jlatexmath:1.0.7'
     implementation 'org.scilab.forge:jlatexmath-font-greek:1.0.7'
@@ -86,8 +86,7 @@ dependencies {
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:$junitVersion"
 
-    implementation "com.theokanning.openai-gpt3-java:api:$chatGPTVersion"
-    implementation "com.theokanning.openai-gpt3-java:service:$chatGPTVersion"
+    implementation "com.openai:openai-java:$chatGPTVersion"
 }
 
 application {

application/src/main/java/org/togetherjava/tjbot/features/Features.java

@@ -39,6 +39,7 @@
 import org.togetherjava.tjbot.features.mathcommands.TeXCommand;
 import org.togetherjava.tjbot.features.mathcommands.wolframalpha.WolframAlphaCommand;
 import org.togetherjava.tjbot.features.mediaonly.MediaOnlyChannelListener;
+import org.togetherjava.tjbot.features.messages.MessageCommand;
 import org.togetherjava.tjbot.features.moderation.BanCommand;
 import org.togetherjava.tjbot.features.moderation.KickCommand;
 import org.togetherjava.tjbot.features.moderation.ModerationActionsStore;
@@ -204,6 +205,7 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new BookmarksCommand(bookmarksSystem));
         features.add(new ChatGptCommand(chatGptService, helpSystemHelper));
         features.add(new JShellCommand(jshellEval));
+        features.add(new MessageCommand());
         features.add(new CreateRoleApplicationCommand(config));
 
         FeatureBlacklist<Class<?>> blacklist = blacklistConfig.normal();

application/src/main/java/org/togetherjava/tjbot/features/VoiceReceiver.java

@@ -0,0 +1,69 @@
+package org.togetherjava.tjbot.features;
+
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceDeafenEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceMuteEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceStreamEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceUpdateEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceVideoEvent;
+
+import java.util.regex.Pattern;
+
+/**
+ * Receives incoming Discord guild events from voice channels matching a given pattern.
+ * <p>
+ * All voice receivers have to implement this interface. For convenience, there is a
+ * {@link VoiceReceiverAdapter} available that implemented most methods already. A new receiver can
+ * then be registered by adding it to {@link Features}.
+ * <p>
+ * <p>
+ * After registration, the system will notify a receiver whenever a new event was sent or an
+ * existing event was updated in any channel matching the {@link #getChannelNamePattern()} the bot
+ * is added to.
+ */
+public interface VoiceReceiver extends Feature {
+    /**
+     * Retrieves the pattern matching the names of channels of which this receiver is interested in
+     * receiving events from. Called by the core system once during the startup in order to register
+     * the receiver accordingly.
+     * <p>
+     * Changes on the pattern returned by this method afterwards will not be picked up.
+     *
+     * @return the pattern matching the names of relevant channels
+     */
+    Pattern getChannelNamePattern();
+
+    /**
+     * Triggered by the core system whenever a member joined, left or moved voice channels.
+     *
+     * @param event the event that triggered this
+     */
+    void onVoiceUpdate(GuildVoiceUpdateEvent event);
+
+    /**
+     * Triggered by the core system whenever a member toggled their camera in a voice channel.
+     *
+     * @param event the event that triggered this
+     */
+    void onVideoToggle(GuildVoiceVideoEvent event);
+
+    /**
+     * Triggered by the core system whenever a member started or stopped a stream.
+     *
+     * @param event the event that triggered this
+     */
+    void onStreamToggle(GuildVoiceStreamEvent event);
+
+    /**
+     * Triggered by the core system whenever a member toggled their mute status.
+     *
+     * @param event the event that triggered this
+     */
+    void onMuteToggle(GuildVoiceMuteEvent event);
+
+    /**
+     * Triggered by the core system whenever a member toggled their deafened status.
+     *
+     * @param event the event that triggered this
+     */
+    void onDeafenToggle(GuildVoiceDeafenEvent event);
+}

application/src/main/java/org/togetherjava/tjbot/features/VoiceReceiverAdapter.java

@@ -0,0 +1,59 @@
+package org.togetherjava.tjbot.features;
+
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceDeafenEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceMuteEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceStreamEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceUpdateEvent;
+import net.dv8tion.jda.api.events.guild.voice.GuildVoiceVideoEvent;
+
+import java.util.regex.Pattern;
+
+/**
+ * Adapter implementation of a {@link VoiceReceiver}. A new receiver can then be registered by
+ * adding it to {@link Features}.
+ * <p>
+ * {@link #onVoiceUpdate(GuildVoiceUpdateEvent)} like the other provided methods can be overridden
+ * if desired. The default implementation is empty, the adapter will not react to such events.
+ */
+public class VoiceReceiverAdapter implements VoiceReceiver {
+
+    private final Pattern channelNamePattern;
+
+    protected VoiceReceiverAdapter() {
+        this(Pattern.compile(".*"));
+    }
+
+    protected VoiceReceiverAdapter(Pattern channelNamePattern) {
+        this.channelNamePattern = channelNamePattern;
+    }
+
+    @Override
+    public Pattern getChannelNamePattern() {
+        return channelNamePattern;
+    }
+
+    @Override
+    public void onVoiceUpdate(GuildVoiceUpdateEvent event) {
+        // Adapter does not react by default, subclasses may change this behavior
+    }
+
+    @Override
+    public void onVideoToggle(GuildVoiceVideoEvent event) {
+        // Adapter does not react by default, subclasses may change this behavior
+    }
+
+    @Override
+    public void onStreamToggle(GuildVoiceStreamEvent event) {
+        // Adapter does not react by default, subclasses may change this behavior
+    }
+
+    @Override
+    public void onMuteToggle(GuildVoiceMuteEvent event) {
+        // Adapter does not react by default, subclasses may change this behavior
+    }
+
+    @Override
+    public void onDeafenToggle(GuildVoiceDeafenEvent event) {
+        // Adapter does not react by default, subclasses may change this behavior
+    }
+}

application/src/main/java/org/togetherjava/tjbot/features/chatgpt/ChatGptService.java

@@ -1,10 +1,11 @@
 package org.togetherjava.tjbot.features.chatgpt;
 
-import com.theokanning.openai.OpenAiHttpException;
-import com.theokanning.openai.completion.chat.ChatCompletionRequest;
-import com.theokanning.openai.completion.chat.ChatMessage;
-import com.theokanning.openai.completion.chat.ChatMessageRole;
-import com.theokanning.openai.service.OpenAiService;
+import com.openai.client.OpenAIClient;
+import com.openai.client.okhttp.OpenAIOkHttpClient;
+import com.openai.models.ChatModel;
+import com.openai.models.responses.Response;
+import com.openai.models.responses.ResponseCreateParams;
+import com.openai.models.responses.ResponseOutputText;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -13,8 +14,8 @@
 import javax.annotation.Nullable;
 
 import java.time.Duration;
-import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 /**
  * Service used to communicate to OpenAI API to generate responses.
@@ -26,30 +27,8 @@ public class ChatGptService {
     /** The maximum number of tokens allowed for the generated answer. */
     private static final int MAX_TOKENS = 3_000;
 
-    /**
-     * This parameter reduces the likelihood of the AI repeating itself. A higher frequency penalty
-     * makes the model less likely to repeat the same lines verbatim. It helps in generating more
-     * diverse and varied responses.
-     */
-    private static final double FREQUENCY_PENALTY = 0.5;
-
-    /**
-     * This parameter controls the randomness of the AI's responses. A higher temperature results in
-     * more varied, unpredictable, and creative responses. Conversely, a lower temperature makes the
-     * model's responses more deterministic and conservative.
-     */
-    private static final double TEMPERATURE = 0.8;
-
-    /**
-     * n: This parameter specifies the number of responses to generate for each prompt. If n is more
-     * than 1, the AI will generate multiple different responses to the same prompt, each one being
-     * a separate iteration based on the input.
-     */
-    private static final int MAX_NUMBER_OF_RESPONSES = 1;
-    private static final String AI_MODEL = "gpt-3.5-turbo";
-
     private boolean isDisabled = false;
-    private OpenAiService openAiService;
+    private OpenAIClient openAIClient;
 
     /**
      * Creates instance of ChatGPTService
@@ -63,23 +42,7 @@ public ChatGptService(Config config) {
             isDisabled = true;
             return;
         }
-
-        openAiService = new OpenAiService(apiKey, TIMEOUT);
-
-        ChatMessage setupMessage = new ChatMessage(ChatMessageRole.SYSTEM.value(), """
-                For code supplied for review, refer to the old code supplied rather than
-                rewriting the code. DON'T supply a corrected version of the code.\s""");
-        ChatCompletionRequest systemSetupRequest = ChatCompletionRequest.builder()
-            .model(AI_MODEL)
-            .messages(List.of(setupMessage))
-            .frequencyPenalty(FREQUENCY_PENALTY)
-            .temperature(TEMPERATURE)
-            .maxTokens(50)
-            .n(MAX_NUMBER_OF_RESPONSES)
-            .build();
-
-        // Sending the system setup message to ChatGPT.
-        openAiService.createChatCompletion(systemSetupRequest);
+        openAIClient = OpenAIOkHttpClient.builder().apiKey(apiKey).timeout(TIMEOUT).build();
     }
 
     /**
@@ -98,32 +61,35 @@ public Optional<String> ask(String question, @Nullable String context) {
         }
 
         String contextText = context == null ? "" : ", Context: %s.".formatted(context);
-        String fullQuestion = "(KEEP IT CONCISE, NOT MORE THAN 280 WORDS%s) - %s"
-            .formatted(contextText, question);
-
-        ChatMessage chatMessage = new ChatMessage(ChatMessageRole.USER.value(), fullQuestion);
-        ChatCompletionRequest chatCompletionRequest = ChatCompletionRequest.builder()
-            .model(AI_MODEL)
-            .messages(List.of(chatMessage))
-            .frequencyPenalty(FREQUENCY_PENALTY)
-            .temperature(TEMPERATURE)
-            .maxTokens(MAX_TOKENS)
-            .n(MAX_NUMBER_OF_RESPONSES)
-            .build();
-        logger.debug("ChatGpt Request: {}", fullQuestion);
+        String inputPrompt = """
+                For code supplied for review, refer to the old code supplied rather than
+                rewriting the code. DON'T supply a corrected version of the code.
+
+                KEEP IT CONCISE, NOT MORE THAN 280 WORDS
+
+                %s
+                Question: %s
+                """.formatted(contextText, question);
+
+        logger.debug("ChatGpt request: {}", inputPrompt);
 
         String response = null;
         try {
-            response = openAiService.createChatCompletion(chatCompletionRequest)
-                .getChoices()
-                .getFirst()
-                .getMessage()
-                .getContent();
-        } catch (OpenAiHttpException openAiHttpException) {
-            logger.warn(
-                    "There was an error using the OpenAI API: {} Code: {} Type: {} Status Code: {}",
-                    openAiHttpException.getMessage(), openAiHttpException.code,
-                    openAiHttpException.type, openAiHttpException.statusCode);
+            ResponseCreateParams params = ResponseCreateParams.builder()
+                .model(ChatModel.GPT_5_NANO)
+                .input(inputPrompt)
+                .maxOutputTokens(MAX_TOKENS)
+                .build();
+
+            Response chatGptResponse = openAIClient.responses().create(params);
+
+            response = chatGptResponse.output()
+                .stream()
+                .flatMap(item -> item.message().stream())
+                .flatMap(message -> message.content().stream())
+                .flatMap(content -> content.outputText().stream())
+                .map(ResponseOutputText::text)
+                .collect(Collectors.joining("\n"));
         } catch (RuntimeException runtimeException) {
             logger.warn("There was an error using the OpenAI API: {}",
                     runtimeException.getMessage());