Reverted a lot of the discordbot parallelism and emoji reaction pre-prompts after hitting rate limits.

Removed some unused code.

Author: kainazzzo

Chat/Discord/DiscordBot.cs

@@ -9,7 +9,6 @@
 using Microsoft.Extensions.Hosting;
 using OpenAI.GPT3.ObjectModels;
 using OpenAI.GPT3.ObjectModels.RequestModels;
-using Org.BouncyCastle.Asn1.X509;
 
 namespace GPT.CLI.Chat.Discord;
 
@@ -34,12 +33,14 @@ public record ChannelOptions
     }
 
 
+    
     private readonly DiscordSocketClient _client;
     private readonly IConfiguration _configuration;
     private readonly OpenAILogic _openAILogic;
     private readonly GPTParameters _defaultParameters;
     private readonly ConcurrentDictionary<ulong, ChannelState> _channelBots = new();
 
+
     public DiscordBot(DiscordSocketClient client, IConfiguration configuration, OpenAILogic openAILogic, GPTParameters defaultParameters)
     {
         _client = client;
@@ -63,6 +64,7 @@ public async Task StartAsync(CancellationToken cancellationToken)
         // Load state from discordState.json
         await LoadState();
 
+        // Login and start
         await _client.LoginAsync(TokenType.Bot, token);
         await _client.StartAsync();
 
@@ -73,15 +75,7 @@ public async Task StartAsync(CancellationToken cancellationToken)
 
 
         // Message receiver is going to run in parallel
-        _client.MessageReceived += message =>
-        {
-#pragma warning disable CS4014
-            return Task.Run(async () =>
-#pragma warning restore CS4014
-            {
-                await HandleMessageReceivedAsync(message);
-            }, cancellationToken);
-        };
+        _client.MessageReceived += HandleMessageReceivedAsync;
 
         _client.MessageUpdated += async (oldMessage, newMessage, channel) =>
         {
@@ -96,25 +90,17 @@ public async Task StartAsync(CancellationToken cancellationToken)
 
 
 
-        _client.Ready += () =>
+        _client.Ready += async () =>
         {
-            Console.WriteLine("Client is ready!");
-            return Task.CompletedTask;
+            await Console.Out.WriteLineAsync("Client is ready!");
         };
 
-        _client.MessageCommandExecuted += (command) =>
+        _client.MessageCommandExecuted += async (command) =>
         {
-            Console.WriteLine($"Command {command.CommandName} executed with result {command.Data.Message.Content}");
-            return Task.CompletedTask;
+            await Console.Out.WriteLineAsync($"Command {command.CommandName} executed with result {command.Data.Message.Content}");
         };
     }
 
-    private async Task AddStandardReactions(IMessage message)
-    {
-        await message.AddReactionAsync(new Emoji("📌"));
-        await message.AddReactionAsync(new Emoji("🔄"));
-    }
-
     private async Task HandleReactionAsync(Cacheable<IUserMessage, ulong> userMessage, Cacheable<IMessageChannel, ulong> messageChannel, SocketReaction reaction)
     {
         if (reaction.UserId == _client.CurrentUser.Id)
@@ -125,6 +111,7 @@ private async Task HandleReactionAsync(Cacheable<IUserMessage, ulong> userMessag
         var message = await userMessage.GetOrDownloadAsync();
         var channel = await messageChannel.GetOrDownloadAsync();
 
+
         switch (reaction.Emote.Name)
         {
             case "📌":
@@ -135,28 +122,30 @@ private async Task HandleReactionAsync(Cacheable<IUserMessage, ulong> userMessag
                     var chatBot = channelState.Chat;
                     chatBot.AddInstruction(new ChatMessage(StaticValues.ChatMessageRoles.User, message.Content));
 
+
                     using var typingState = channel.EnterTypingState();
                     await message.RemoveReactionAsync(reaction.Emote, reaction.UserId);
                     await message.ReplyAsync("Instruction added.");
-
-                    Console.WriteLine(
-                        $"{reaction.User.Value.Username} reacted with an arrow up. Message promoted to instruction: {message.Content}");
                 }
+
                 break;
             }
             case "🔄":
             {
-                // remove the emoji
-                await message.RemoveReactionAsync(reaction.Emote, reaction.UserId);
+                // If the message is from the bot, ignore it. These aren't prompts.
+                if (message.Author.Id == _client.CurrentUser.Id)
+                {
+                    return;
+                }
 
-                await message.ReplyAsync("Using as a prompt.");
+                // remove the emoji
+                await message.RemoveReactionAsync(reaction.Emote, reaction.User.Value);
 
                 // Replay the message as a new message
-#pragma warning disable CS4014
-                Task.Run(async () => await HandleMessageReceivedAsync(message, reaction.Emote));
-#pragma warning restore CS4014
+                await HandleMessageReceivedAsync(message as SocketMessage);
                 break;
             }
+
         }
     }
 
@@ -222,7 +211,6 @@ private async Task<ChannelState> ReadAsync(ulong channelId, Stream stream)
         try
         {
             var str = await new StreamReader(stream).ReadToEndAsync();
-            await Console.Out.WriteLineAsync($"State read for {channelId}: {str}");
             // Deserialize channelState from stream
             var channelState = JsonSerializer.Deserialize<ChannelState>(str);
 
@@ -252,18 +240,16 @@ private async Task LogAsync(LogMessage log)
         await Console.Out.WriteLineAsync(log.ToString());
     }
 
-    private async Task HandleMessageReceivedAsync(IMessage message, IEmote emote = null)
+    private async Task HandleMessageReceivedAsync(SocketMessage message)
     {
-        if (message.Author.Id == _client.CurrentUser.Id && emote == null)
+        if (message == null || message.Author.Id == _client.CurrentUser.Id)
             return;
 
         // Handle the received message here
         // ...
-        if (!_channelBots.TryGetValue(message.Channel.Id, out var channel))
-        {
-            channel = InitializeChannel(message.Channel.Id);
-        }
-        else if (channel.Chat.State.PrimeDirectives.Count != _defaultPrimeDirective.Count || channel.Chat.State.PrimeDirectives[0].Content != _defaultPrimeDirective[0].Content)
+        var channel = _channelBots.GetOrAdd(message.Channel.Id, InitializeChannel);
+       
+        if (channel.Chat.State.PrimeDirectives.Count != _defaultPrimeDirective.Count || channel.Chat.State.PrimeDirectives[0].Content != _defaultPrimeDirective[0].Content)
         {
             channel.Chat.State.PrimeDirectives = PrimeDirective.ToList();
         }
@@ -274,74 +260,58 @@ private async Task HandleMessageReceivedAsync(IMessage message, IEmote emote = n
         if (message.Content.StartsWith("!ignore"))
             return;
 
-        await message.AddReactionAsync(new Emoji("🤔"));
-
-        await AddStandardReactions(message);
 
         // Add this message as a chat log
         await channel.Chat.AddMessage(new ChatMessage(StaticValues.ChatMessageRoles.User, $"<{message.Author.Username}> {message.Content}"));
 
         if (!channel.Options.Muted)
         {
-            try
+            using var typingState = message.Channel.EnterTypingState();
+            // Get the response from the bot
+            var responses = channel.Chat.GetResponseAsync();
+            // Add the response as a chat 
+            
+            var sb = new StringBuilder();
+            // Send the response to the channel
+            await foreach (var response in responses)
             {
-                
-                // Get the response from the bot
-                var responses = channel.Chat.GetResponseAsync();
-                // Add the response as a chat 
-                
-                using var typingState = message.Channel.EnterTypingState();
-
-                var sb = new StringBuilder();
-                // Send the response to the channel
-                await foreach (var response in responses)
+                if (response.Successful)
                 {
-                    if (response.Successful)
+                    var content = response.Choices.FirstOrDefault()?.Message.Content;
+                    if (content is not null)
                     {
-                        var content = response?.Choices?.FirstOrDefault()?.Message.Content;
-                        if (content is not null)
-                        {
-                            sb.Append(content);
-                        }
-                    }
-                    else
-                    {
-                        await Console.Out.WriteLineAsync(
-                            $"Error code {response.Error?.Code}: {response.Error?.Message}");
+                        sb.Append(content);
                     }
                 }
-
-                int chunkSize = 2000;
-                int currentPosition = 0;
-
-                while (currentPosition < sb.Length)
+                else
                 {
-                    var size = Math.Min(chunkSize, sb.Length - currentPosition);
-                    var chunk = sb.ToString(currentPosition, size);
-                    currentPosition += size;
+                    await Console.Out.WriteLineAsync(
+                        $"Error code {response.Error?.Code}: {response.Error?.Message}");
+                }
+            }
 
-                    var responseMessage = new ChatMessage(StaticValues.ChatMessageRoles.Assistant, chunk);
+            int chunkSize = 2000;
+            int currentPosition = 0;
 
-                    await channel.Chat.AddMessage(responseMessage);
-                    // Convert message to SocketMessage
-                    IMessage newMessage;
+            while (currentPosition < sb.Length)
+            {
+                var size = Math.Min(chunkSize, sb.Length - currentPosition);
+                var chunk = sb.ToString(currentPosition, size);
+                currentPosition += size;
 
-                    if (message is IUserMessage userMessage)
-                    {
-                        newMessage = await userMessage.ReplyAsync(responseMessage.Content);
-                    }
-                    else
-                    {
+                var responseMessage = new ChatMessage(StaticValues.ChatMessageRoles.Assistant, chunk);
 
-                        newMessage = await message.Channel.SendMessageAsync(responseMessage.Content);
-                    }
+                await channel.Chat.AddMessage(responseMessage);
+                // Convert message to SocketMessage
 
-                    await AddStandardReactions(newMessage);
+                if (message is IUserMessage userMessage)
+                {
+                    _ = await userMessage.ReplyAsync(responseMessage.Content);
+                }
+                else
+                {
+                    _ = await message.Channel.SendMessageAsync(responseMessage.Content);
                 }
-            }
-            finally
-            {
-                await message.RemoveReactionAsync(new Emoji("🤔"), _client.CurrentUser);
             }
         }
 
@@ -354,7 +324,7 @@ await Console.Out.WriteLineAsync(
         (StaticValues.ChatMessageRoles.System,
             "This is the Prime Directive: This is a chat bot running in [GPT-CLI](https://github.com/kainazzzo/GPT-CLI). Answer questions and" +
             " provide responses in Discord message formatting. Encourage users to add instructions with /gptcli or by using the :up_arrow:" +
-            " emoji reaction on any message. Instructions are like 'sticky' chat messages that provide upfront context to the bot.")
+            " emoji reaction on any message. Instructions are like 'sticky' chat messages that provide upfront context to the bot. The the 📌 emoji reaction is for pinning a message to instructions. The 🔄 emoji reaction is for replaying a message as a new prompt.")
     };
 
     private IEnumerable<ChatMessage> PrimeDirective => _defaultPrimeDirective;

Program.cs

@@ -1,4 +1,5 @@
-using System.CommandLine;
+using System.Collections.Concurrent;
+using System.CommandLine;
 using System.CommandLine.Builder;
 using System.CommandLine.Parsing;
 using System.Text;
@@ -144,6 +145,7 @@ static async Task Main(string[] args)
             ConfigureServices(services, binder, mode);
 
             await using var serviceProvider = services.BuildServiceProvider();
+            
 
             // get a OpenAILogic instance
             var openAILogic = serviceProvider.GetService<OpenAILogic>();
@@ -387,18 +389,18 @@ private static void ConfigureServices(IServiceCollection services, GPTParameters
             settings.BaseDomain = gptParameters.BaseDomain;
         });
         services.AddSingleton<OpenAILogic>();
-        services.AddSingleton(_ =>
-        {
-            var config = new DiscordSocketConfig
-            {
-                GatewayIntents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.GuildMembers | 
-                                 GatewayIntents.MessageContent | GatewayIntents.DirectMessages | GatewayIntents.DirectMessageReactions | 
-                                 GatewayIntents.GuildMessageReactions | GatewayIntents.GuildEmojis,
-                MessageCacheSize = 100
-            };
 
-            return new DiscordSocketClient(config);
+        services.AddSingleton(_ => new DiscordSocketConfig
+        {
+            GatewayIntents = GatewayIntents.Guilds | GatewayIntents.GuildMessages | GatewayIntents.GuildMembers |
+                             GatewayIntents.MessageContent | GatewayIntents.DirectMessages |
+                             GatewayIntents.DirectMessageReactions |
+                             GatewayIntents.GuildMessageReactions | GatewayIntents.GuildEmojis,
+            MessageCacheSize = 10
         });
+
+        services.AddScoped<DiscordSocketClient>();
+        
         services.AddSingleton<DiscordBot>();
         services.AddSingleton(_ => gptParameters);
 
@@ -445,61 +447,4 @@ private static void ConfigureServices(IServiceCollection services, GPTParameters
     }
 
     public static IConfigurationRoot Configuration { get; set; }
-
-    private static bool VerifySignature(string publicKey, string signature, string timestamp, string body)
-    {
-        byte[] publicKeyBytes = StringToByteArray(publicKey);
-        byte[] signatureBytes = StringToByteArray(signature);
-        byte[] timestampBytes = Encoding.UTF8.GetBytes(timestamp);
-        byte[] bodyBytes = Encoding.UTF8.GetBytes(body);
-
-        var pubKeyParam = new Ed25519PublicKeyParameters(publicKeyBytes, 0);
-        var verifier = SignerUtilities.GetSigner("Ed25519");
-
-        verifier.Init(false, pubKeyParam);
-
-        byte[] combinedBytes = new byte[timestampBytes.Length + bodyBytes.Length];
-        Buffer.BlockCopy(timestampBytes, 0, combinedBytes, 0, timestampBytes.Length);
-        Buffer.BlockCopy(bodyBytes, 0, combinedBytes, timestampBytes.Length, bodyBytes.Length);
-
-        verifier.BlockUpdate(combinedBytes, 0, combinedBytes.Length);
-
-        return verifier.VerifySignature(signatureBytes);
-
-        
-    }
-    private static byte[] StringToByteArray(string hex)
-    {
-        int length = hex.Length;
-        byte[] bytes = new byte[length / 2];
-        for (int i = 0; i < length; i += 2)
-        {
-            bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
-        }
-        return bytes;
-    }
-    
-
-    public class InteractionPayload
-    {
-        public string ApplicationId { get; set; }
-        public string Id { get; set; }
-        public string Token { get; set; }
-        public int Type { get; set; }
-        public InteractionUser User { get; set; }
-        public int Version { get; set; }
-    }
-
-    public class InteractionUser
-    {
-        public string Avatar { get; set; }
-        public object AvatarDecoration { get; set; }
-        public string Discriminator { get; set; }
-        public object DisplayName { get; set; }
-        public object GlobalName { get; set; }
-        public string Id { get; set; }
-        public int PublicFlags { get; set; }
-        public string Username { get; set; }
-    }
-
 }

test.bat

@@ -0,0 +1 @@
+git log -1 --pretty=%B | xargs -I % dotnet publish gpt.csproj -c Release -r win-x64 -o c:\bin\ --self-contained true -p:PublishSingleFile=true -p:VersionSuffix=%