feat: add tools to AI (#1489)

* feat: update chatgpt to have an opt-in thinking mode. This allows for the AI to have tool usage. The tool included with this PR is web search.

Author: surajkumar

.gitattributes

@@ -1,5 +1,7 @@
-# This will do normalization to LF on index (staging area) 
-* text=auto
+# Normalize to LF in the index AND in the working tree on all platforms.
+# Spotless enforces LF, so without eol=lf, Windows/WSL checkouts get CRLF and
+# every spotlessApply rewrites every file.
+* text=auto eol=lf
 
 # Explicit for linux files
 *.sh     text eol=lf

application/config.json.template

@@ -162,6 +162,7 @@
     "logInfoChannelWebhook": "<put_your_webhook_here>",
     "logErrorChannelWebhook": "<put_your_webhook_here>",
     "openaiApiKey": "<check pins in #tjbot_discussion for the key>",
+    "tavilyApiKey": "<create an account on https://www.tavily.com/ to get an API key for free>",
     "sourceCodeBaseUrl": "https://github.com/Together-Java/TJ-Bot/blob/master/application/src/main/java/",
     "jshell": {
         "baseUrl": "<put_jshell_rest_api_url_here>",

application/src/main/java/org/togetherjava/tjbot/config/Config.java

@@ -52,6 +52,7 @@ public final class Config {
     private final QuoteBoardConfig quoteBoardConfig;
     private final TopHelpersConfig topHelpers;
     private final DynamicVoiceChatConfig dynamicVoiceChatConfig;
+    private final String tavilyApiKey;
 
     @SuppressWarnings("ConstructorWithTooManyParameters")
     @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
@@ -111,7 +112,8 @@ private Config(@JsonProperty(value = "token", required = true) String token,
                     required = true) RoleApplicationSystemConfig roleApplicationSystemConfig,
             @JsonProperty(value = "topHelpers", required = true) TopHelpersConfig topHelpers,
             @JsonProperty(value = "dynamicVoiceChatConfig",
-                    required = true) DynamicVoiceChatConfig dynamicVoiceChatConfig) {
+                    required = true) DynamicVoiceChatConfig dynamicVoiceChatConfig,
+            @JsonProperty(value = "tavilyApiKey", required = true) String tavilyApiKey) {
         this.token = Objects.requireNonNull(token);
         this.githubApiKey = Objects.requireNonNull(githubApiKey);
         this.databasePath = Objects.requireNonNull(databasePath);
@@ -150,6 +152,7 @@ private Config(@JsonProperty(value = "token", required = true) String token,
         this.roleApplicationSystemConfig = roleApplicationSystemConfig;
         this.topHelpers = Objects.requireNonNull(topHelpers);
         this.dynamicVoiceChatConfig = Objects.requireNonNull(dynamicVoiceChatConfig);
+        this.tavilyApiKey = Objects.requireNonNull(tavilyApiKey);
     }
 
     /**
@@ -499,4 +502,16 @@ public TopHelpersConfig getTopHelpers() {
     public DynamicVoiceChatConfig getDynamicVoiceChatConfig() {
         return dynamicVoiceChatConfig;
     }
+
+    /**
+     * Gets the API key for Tavily ({@link <a href="https://www.tavily.com">tavily.com</a>}), a
+     * search engine API tailored for LLMs. It is used by the ChatGPT command to power the AI-driven
+     * web search tool, allowing the assistant to fetch up-to-date information from the web when
+     * answering user questions.
+     *
+     * @return the Tavily API key
+     */
+    public String getTavilyApiKey() {
+        return tavilyApiKey;
+    }
 }

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

@@ -19,6 +19,8 @@
 import org.togetherjava.tjbot.features.bookmarks.LeftoverBookmarksListener;
 import org.togetherjava.tjbot.features.chatgpt.ChatGptCommand;
 import org.togetherjava.tjbot.features.chatgpt.ChatGptService;
+import org.togetherjava.tjbot.features.chatgpt.tools.web.FetchUrlTool;
+import org.togetherjava.tjbot.features.chatgpt.tools.web.WebSearchTool;
 import org.togetherjava.tjbot.features.code.CodeMessageAutoDetection;
 import org.togetherjava.tjbot.features.code.CodeMessageHandler;
 import org.togetherjava.tjbot.features.code.CodeMessageManualDetection;
@@ -88,6 +90,7 @@
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 
 /**
  * Utility class that offers all features that should be registered by the system, such as commands.
@@ -218,7 +221,10 @@ public static Collection<Feature> createFeatures(JDA jda, Database database, Con
         features.add(new HelpThreadCommand(config, helpSystemHelper, metrics));
         features.add(new ReportCommand(config));
         features.add(new BookmarksCommand(bookmarksSystem));
-        features.add(new ChatGptCommand(chatGptService, helpSystemHelper));
+
+        features.add(new ChatGptCommand(chatGptService, helpSystemHelper,
+                List.of(new WebSearchTool(config.getTavilyApiKey()), new FetchUrlTool())));
+
         features.add(new JShellCommand(jshellEval));
         features.add(new MessageCommand());
         features.add(new RewriteCommand(chatGptService));

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

@@ -2,23 +2,33 @@
 
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
+import net.dv8tion.jda.api.EmbedBuilder;
 import net.dv8tion.jda.api.entities.MessageEmbed;
 import net.dv8tion.jda.api.entities.SelfUser;
+import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion;
 import net.dv8tion.jda.api.events.interaction.ModalInteractionEvent;
 import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
+import net.dv8tion.jda.api.interactions.InteractionHook;
+import net.dv8tion.jda.api.interactions.commands.OptionMapping;
+import net.dv8tion.jda.api.interactions.commands.OptionType;
 import net.dv8tion.jda.api.interactions.components.text.TextInput;
 import net.dv8tion.jda.api.interactions.components.text.TextInputStyle;
 import net.dv8tion.jda.api.interactions.modals.Modal;
 
 import org.togetherjava.tjbot.features.CommandVisibility;
 import org.togetherjava.tjbot.features.SlashCommandAdapter;
+import org.togetherjava.tjbot.features.chatgpt.tools.AiTool;
 import org.togetherjava.tjbot.features.help.HelpSystemHelper;
 
 import java.time.Duration;
 import java.time.Instant;
 import java.time.temporal.ChronoUnit;
 import java.util.List;
-import java.util.Optional;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
 
 /**
  * The implemented command is {@code /chatgpt}, which allows users to ask ChatGPT a question, upon
@@ -27,12 +37,31 @@
 public final class ChatGptCommand extends SlashCommandAdapter {
     private static final ChatGptModel CHAT_GPT_MODEL = ChatGptModel.HIGH_QUALITY;
     public static final String COMMAND_NAME = "chatgpt";
+    private static final String THINKING_OPTION = "enable_thinking";
     private static final String QUESTION_INPUT = "question";
     private static final int MAX_MESSAGE_INPUT_LENGTH = 200;
     private static final int MIN_MESSAGE_INPUT_LENGTH = 4;
     private static final Duration COMMAND_COOLDOWN = Duration.of(10, ChronoUnit.SECONDS);
+    private static final String ERROR_RESPONSE = """
+                An error has occurred while trying to communicate with ChatGPT.
+                Please try again later.
+            """;
+    private static final String SYSTEM_PROMPT =
+            """
+                    You are a helpful assistant answering questions in a Discord server.
+                    Keep responses concise (no more than 280 words) and use markdown when helpful.
+                    When the user's question depends on live or external information, prefer calling \
+                    the `web_search` tool for current facts and the `fetch_url` tool to read a specific page.
+                    For code review questions, refer to the supplied code rather than rewriting it.""";
+
     private final ChatGptService chatGptService;
     private final HelpSystemHelper helper;
+    private final List<AiTool<?>> tools;
+    private final Executor worker = Executors.newCachedThreadPool(runnable -> {
+        Thread thread = new Thread(runnable, "chatgpt-worker");
+        thread.setDaemon(true);
+        return thread;
+    });
 
     private final Cache<String, Instant> userIdToAskedAtCache =
             Caffeine.newBuilder().maximumSize(1_000).expireAfterWrite(COMMAND_COOLDOWN).build();
@@ -42,17 +71,24 @@ public final class ChatGptCommand extends SlashCommandAdapter {
      *
      * @param chatGptService ChatGptService - Needed to make calls to ChatGPT API
      * @param helper HelpSystemHelper - Needed to generate response embed for prompt
+     * @param tools tools the model may invoke while answering; pass an empty list to disable
      */
-    public ChatGptCommand(ChatGptService chatGptService, HelpSystemHelper helper) {
+    public ChatGptCommand(ChatGptService chatGptService, HelpSystemHelper helper,
+            List<AiTool<?>> tools) {
         super(COMMAND_NAME, "Ask the ChatGPT AI a question!", CommandVisibility.GUILD);
 
         this.chatGptService = chatGptService;
         this.helper = helper;
+        this.tools = tools;
+
+        getData().addOption(OptionType.BOOLEAN, THINKING_OPTION,
+                "let the model use web tools (search/fetch) to answer", false);
     }
 
     @Override
     public void onSlashCommand(SlashCommandInteractionEvent event) {
-        Instant previousAskTime = userIdToAskedAtCache.getIfPresent(event.getMember().getId());
+        Instant previousAskTime = userIdToAskedAtCache
+            .getIfPresent(Objects.requireNonNull(event.getMember()).getId());
         if (previousAskTime != null) {
             long timeRemainingUntilNextAsk =
                     COMMAND_COOLDOWN.minus(Duration.between(previousAskTime, Instant.now()))
@@ -66,40 +102,85 @@ public void onSlashCommand(SlashCommandInteractionEvent event) {
             return;
         }
 
+        OptionMapping thinkingOption = event.getOption(THINKING_OPTION);
+        boolean thinkingEnabled = thinkingOption != null && thinkingOption.getAsBoolean();
+
         TextInput body = TextInput
             .create(QUESTION_INPUT, "Ask ChatGPT a question or get help with code",
                     TextInputStyle.PARAGRAPH)
             .setPlaceholder("Put your question for ChatGPT here")
             .setRequiredRange(MIN_MESSAGE_INPUT_LENGTH, MAX_MESSAGE_INPUT_LENGTH)
             .build();
 
-        Modal modal = Modal.create(generateComponentId(), "ChatGPT").addActionRow(body).build();
+        Modal modal =
+                Modal.create(generateComponentId(Boolean.toString(thinkingEnabled)), "ChatGPT")
+                    .addActionRow(body)
+                    .build();
         event.replyModal(modal).queue();
     }
 
     @Override
     public void onModalSubmitted(ModalInteractionEvent event, List<String> args) {
         event.deferReply().queue();
 
-        String question = event.getValue(QUESTION_INPUT).getAsString();
-
-        Optional<String> chatgptResponse = chatGptService.ask(question,
-                "You may use markdown syntax for the response", CHAT_GPT_MODEL);
-        if (chatgptResponse.isPresent()) {
-            userIdToAskedAtCache.put(event.getMember().getId(), Instant.now());
-        }
-
-        String errorResponse = """
-                    An error has occurred while trying to communicate with ChatGPT.
-                    Please try again later.
-                """;
-
-        String response = chatgptResponse.orElse(errorResponse);
+        String question = Objects.requireNonNull(event.getValue(QUESTION_INPUT)).getAsString();
         SelfUser selfUser = event.getJDA().getSelfUser();
+        InteractionHook hook = event.getHook();
+        MessageChannelUnion channel = event.getChannel();
+        String userId = Objects.requireNonNull(event.getMember()).getId();
+        boolean thinkingEnabled = !args.isEmpty() && Boolean.parseBoolean(args.getFirst());
+        List<AiTool<?>> activeTools = thinkingEnabled ? tools : List.<AiTool<?>>of();
+
+        ChatGptProgressEmbed progress = new ChatGptProgressEmbed(hook, selfUser, question);
+        hook.editOriginalEmbeds(progress.initialEmbed()).queue();
+
+        Instant startedAt = Instant.now();
+        CompletableFuture
+            .supplyAsync(() -> chatGptService.askWithTools(question, CHAT_GPT_MODEL, activeTools,
+                    SYSTEM_PROMPT, progress), worker)
+            .whenComplete((result, throwable) -> {
+                String response;
+                if (throwable == null && result.isPresent()) {
+                    response = result.get();
+                    userIdToAskedAtCache.put(userId, Instant.now());
+                } else {
+                    response = ERROR_RESPONSE;
+                }
+                finishResponse(hook, channel, selfUser, question, response,
+                        Duration.between(startedAt, Instant.now()));
+            });
+    }
 
-        MessageEmbed responseEmbed =
+    private void finishResponse(InteractionHook hook, MessageChannelUnion channel,
+            SelfUser selfUser, String question, String response, Duration elapsed) {
+        MessageEmbed baseEmbed =
                 helper.generateGptResponseEmbed(response, selfUser, question, CHAT_GPT_MODEL);
+        MessageEmbed finalEmbed = withTimingFooter(baseEmbed, elapsed);
+
+        channel.sendMessageEmbeds(finalEmbed).queue(_ -> hook.deleteOriginal().queue(null, _ -> {
+        }), _ -> hook.deleteOriginal().queue(null, _ -> {
+        }));
+    }
 
-        event.getHook().sendMessageEmbeds(responseEmbed).queue();
+    private static MessageEmbed withTimingFooter(MessageEmbed embed, Duration elapsed) {
+        String existing = embed.getFooter() == null ? "" : embed.getFooter().getText();
+        String suffix = "took %s".formatted(formatDuration(elapsed));
+        String footer = existing == null || existing.isBlank() ? suffix
+                : "%s · %s".formatted(existing, suffix);
+        return new EmbedBuilder(embed).setFooter(footer).build();
+    }
+
+    private static String formatDuration(Duration elapsed) {
+        long totalMs = Math.max(0, elapsed.toMillis());
+        if (totalMs < 1_000) {
+            return totalMs + "ms";
+        }
+        long totalSeconds = totalMs / 1_000;
+        if (totalSeconds < 60) {
+            return String.format(Locale.ROOT, "%.1fs", totalMs / 1000.0);
+        }
+        long minutes = totalSeconds / 60;
+        long seconds = totalSeconds % 60;
+        return "%dm %ds".formatted(minutes, seconds);
     }
 }