diff --git a/DisCatSharp.ApplicationCommands/Context/BaseContext.cs b/DisCatSharp.ApplicationCommands/Context/BaseContext.cs
index a7443f35f..d88cd5163 100644
--- a/DisCatSharp.ApplicationCommands/Context/BaseContext.cs
+++ b/DisCatSharp.ApplicationCommands/Context/BaseContext.cs
@@ -1,180 +1,180 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
 using System;
 using System.Threading.Tasks;
 using DisCatSharp.Entities;
 using DisCatSharp.Enums;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace DisCatSharp.ApplicationCommands
 {
     /// <summary>
     /// Respresents a base context for application command contexts.
     /// </summary>
     public class BaseContext
     {
         /// <summary>
         /// Gets the interaction that was created.
         /// </summary>
         public DiscordInteraction Interaction { get; internal set; }
 
         /// <summary>
         /// Gets the client for this interaction.
         /// </summary>
         public DiscordClient Client { get; internal set; }
 
         /// <summary>
         /// Gets the guild this interaction was executed in.
         /// </summary>
         public DiscordGuild Guild { get; internal set; }
 
         /// <summary>
         /// Gets the channel this interaction was executed in.
         /// </summary>
         public DiscordChannel Channel { get; internal set; }
 
         /// <summary>
         /// Gets the user which executed this interaction.
         /// </summary>
         public DiscordUser User { get; internal set; }
 
         /// <summary>
         /// Gets the member which executed this interaction, or null if the command is in a DM.
         /// </summary>
         public DiscordMember Member
             => this.User is DiscordMember member ? member : null;
 
         /// <summary>
         /// Gets the application command module this interaction was created in.
         /// </summary>
         public ApplicationCommandsExtension ApplicationCommandsExtension { get; internal set; }
 
         /// <summary>
         /// Gets the token for this interaction.
         /// </summary>
         public string Token { get; internal set; }
 
         /// <summary>
         /// Gets the id for this interaction.
         /// </summary>
         public ulong InteractionId { get; internal set; }
 
         /// <summary>
         /// Gets the name of the command.
         /// </summary>
         public string CommandName { get; internal set; }
 
         /// <summary>
         /// Gets the invoking user locale.
         /// </summary>
         public string Locale { get; internal set; }
 
         /// <summary>
         /// Gets the guild locale if applicable.
         /// </summary>
         public string GuildLocale { get; internal set; }
 
         /// <summary>
         /// Gets the type of this interaction.
         /// </summary>
         public ApplicationCommandType Type { get; internal set;}
 
         /// <summary>
         /// <para>Gets the service provider.</para>
         /// <para>This allows passing data around without resorting to static members.</para>
         /// <para>Defaults to null.</para>
         /// </summary>
         public IServiceProvider Services { get; internal set; } = new ServiceCollection().BuildServiceProvider(true);
 
         /// <summary>
         /// Creates a response to this interaction.
         /// <para>You must create a response within 3 seconds of this interaction being executed; if the command has the potential to take more than 3 seconds, create a <see cref="InteractionResponseType.DeferredChannelMessageWithSource"/> at the start, and edit the response later.</para>
         /// </summary>
         /// <param name="type">The type of the response.</param>
         /// <param name="builder">The data to be sent, if any.</param>
         /// <returns></returns>
         public Task CreateResponseAsync(InteractionResponseType type, DiscordInteractionResponseBuilder builder = null)
             => this.Interaction.CreateResponseAsync(type, builder);
 
         /// <summary>
         /// Creates a modal response to this interaction.
         /// </summary>
         /// <param name="builder">The data to send.</param>
-        public Task CreateModalResponseAsync(DiscordInteractionModalBuilder builder) =>
-            this.Interaction.CreateInteractionModalResponseAsync(builder);
+        public Task CreateModalResponseAsync(DiscordInteractionModalBuilder builder)
+            => this.Interaction.Type != InteractionType.Ping && this.Interaction.Type != InteractionType.ModalSubmit ? this.Interaction.CreateInteractionModalResponseAsync(builder) : throw new NotSupportedException("You can't respond to an PING with a modal.");
 
         /// <summary>
         /// Edits the interaction response.
         /// </summary>
         /// <param name="builder">The data to edit the response with.</param>
         /// <returns></returns>
         public Task<DiscordMessage> EditResponseAsync(DiscordWebhookBuilder builder)
             => this.Interaction.EditOriginalResponseAsync(builder);
 
         /// <summary>
         /// Deletes the interaction response.
         /// </summary>
         /// <returns></returns>
         public Task DeleteResponseAsync()
             => this.Interaction.DeleteOriginalResponseAsync();
 
         /// <summary>
         /// Creates a follow up message to the interaction.
         /// </summary>
         /// <param name="builder">The message to be sent, in the form of a webhook.</param>
         /// <returns>The created message.</returns>
         public Task<DiscordMessage> FollowUpAsync(DiscordFollowupMessageBuilder builder)
             => this.Interaction.CreateFollowupMessageAsync(builder);
 
         /// <summary>
         /// Edits a followup message.
         /// </summary>
         /// <param name="followupMessageId">The id of the followup message to edit.</param>
         /// <param name="builder">The webhook builder.</param>
         /// <returns></returns>
         public Task<DiscordMessage> EditFollowupAsync(ulong followupMessageId, DiscordWebhookBuilder builder)
             => this.Interaction.EditFollowupMessageAsync(followupMessageId, builder);
 
         /// <summary>
         /// Deletes a followup message.
         /// </summary>
         /// <param name="followupMessageId">The id of the followup message to delete.</param>
         /// <returns></returns>
         public Task DeleteFollowupAsync(ulong followupMessageId)
             => this.Interaction.DeleteFollowupMessageAsync(followupMessageId);
 
         /// <summary>
         /// Gets the followup message.
         /// </summary>
         /// <param name="followupMessageId">The followup message id.</param>
         public Task<DiscordMessage> GetFollowupMessageAsync(ulong followupMessageId)
             => this.Interaction.GetFollowupMessageAsync(followupMessageId);
 
         /// <summary>
         /// Gets the original interaction response.
         /// </summary>
         /// <returns>The original interaction response.</returns>
         public Task<DiscordMessage> GetOriginalResponseAsync()
              => this.Interaction.GetOriginalResponseAsync();
     }
 }
diff --git a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
index e26159bc2..3c6f55402 100644
--- a/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
+++ b/DisCatSharp/Entities/Interaction/DiscordInteraction.cs
@@ -1,218 +1,219 @@
 // This file is part of the DisCatSharp project.
 //
 // Copyright (c) 2021 AITSYS
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in all
 // copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
+using System;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
 
 namespace DisCatSharp.Entities
 {
     /// <summary>
     /// Represents an interaction that was invoked.
     /// </summary>
     public sealed class DiscordInteraction : SnowflakeObject
     {
         /// <summary>
         /// Gets the type of interaction invoked.
         /// </summary>
         [JsonProperty("type")]
         public InteractionType Type { get; internal set; }
 
         /// <summary>
         /// Gets the command data for this interaction.
         /// </summary>
         [JsonProperty("data", NullValueHandling = NullValueHandling.Ignore)]
         public DiscordInteractionData Data { get; internal set; }
 
         /// <summary>
         /// Gets the Id of the guild that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public ulong? GuildId { get; internal set; }
 
         /// <summary>
         /// Gets the guild that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public DiscordGuild Guild
             => (this.Discord as DiscordClient).InternalGetCachedGuild(this.GuildId);
 
         /// <summary>
         /// Gets the Id of the channel that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public ulong ChannelId { get; internal set; }
 
         /// <summary>
         /// Gets the channel that invoked this interaction.
         /// </summary>
         [JsonIgnore]
         public DiscordChannel Channel
              => (this.Discord as DiscordClient).InternalGetCachedChannel(this.ChannelId) ?? (DiscordChannel)(this.Discord as DiscordClient).InternalGetCachedThread(this.ChannelId) ?? (this.Guild == null ? new DiscordDmChannel { Id = this.ChannelId, Type = ChannelType.Private, Discord = this.Discord } : null);
 
         /// <summary>
         /// Gets the user that invoked this interaction.
         /// <para>This can be cast to a <see cref="DisCatSharp.Entities.DiscordMember"/> if created in a guild.</para>
         /// </summary>
         [JsonIgnore]
         public DiscordUser User { get; internal set; }
 
         /// <summary>
         /// Gets the continuation token for responding to this interaction.
         /// </summary>
         [JsonProperty("token")]
         public string Token { get; internal set; }
 
         /// <summary>
         /// Gets the version number for this interaction type.
         /// </summary>
         [JsonProperty("version")]
         public int Version { get; internal set; }
 
         /// <summary>
         /// Gets the ID of the application that created this interaction.
         /// </summary>
         [JsonProperty("application_id")]
         public ulong ApplicationId { get; internal set; }
 
         /// <summary>
         /// The message this interaction was created with, if any.
         /// </summary>
         [JsonProperty("message")]
         internal DiscordMessage Message { get; set; }
 
         /// <summary>
         /// Gets the invoking user locale.
         /// </summary>
         [JsonProperty("locale", NullValueHandling = NullValueHandling.Ignore)]
         public string Locale { get; internal set; }
 
         /// <summary>
         /// Gets the guild locale if applicable.
         /// </summary>
         [JsonProperty("guild_locale", NullValueHandling = NullValueHandling.Ignore)]
         public string GuildLocale { get; internal set; }
 
         /// <summary>
         /// Creates a response to this interaction.
         /// </summary>
         /// <param name="type">The type of the response.</param>
         /// <param name="builder">The data, if any, to send.</param>
-        public Task CreateResponseAsync(InteractionResponseType type, DiscordInteractionResponseBuilder builder = null) =>
-            this.Discord.ApiClient.CreateInteractionResponseAsync(this.Id, this.Token, type, builder);
+        public Task CreateResponseAsync(InteractionResponseType type, DiscordInteractionResponseBuilder builder = null)
+            => this.Discord.ApiClient.CreateInteractionResponseAsync(this.Id, this.Token, type, builder);
 
         /// <summary>
         /// Creates a modal response to this interaction.
         /// </summary>
         /// <param name="builder">The data to send.</param>
-        public Task CreateInteractionModalResponseAsync(DiscordInteractionModalBuilder builder) =>
-            this.Discord.ApiClient.CreateInteractionModalResponseAsync(this.Id, this.Token, InteractionResponseType.Modal, builder);
+        public Task CreateInteractionModalResponseAsync(DiscordInteractionModalBuilder builder)
+            => this.Type != InteractionType.Ping && this.Type != InteractionType.ModalSubmit ?  this.Discord.ApiClient.CreateInteractionModalResponseAsync(this.Id, this.Token, InteractionResponseType.Modal, builder) : throw new NotSupportedException("You can't respond to an PING with a modal.");
 
         /// <summary>
         /// Gets the original interaction response.
         /// </summary>
         /// <returns>The origingal message that was sent. This <b>does not work on ephemeral messages.</b></returns>
-        public Task<DiscordMessage> GetOriginalResponseAsync() =>
-            this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
+        public Task<DiscordMessage> GetOriginalResponseAsync()
+            => this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
         /// <summary>
         /// Edits the original interaction response.
         /// </summary>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The edited <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> EditOriginalResponseAsync(DiscordWebhookBuilder builder)
         {
             builder.Validate(isInteractionResponse: true);
             if (builder._keepAttachments.HasValue && builder._keepAttachments.Value)
             {
                 var attachments = this.Discord.ApiClient.GetOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token).Result.Attachments;
                 if (attachments?.Count > 0)
                 {
                     builder._attachments.AddRange(attachments);
                 }
             }
             else if (builder._keepAttachments.HasValue)
             {
                 builder._attachments.Clear();
             }
 
             return await this.Discord.ApiClient.EditOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes the original interaction response.
         /// </summary>>
-        public Task DeleteOriginalResponseAsync() =>
-            this.Discord.ApiClient.DeleteOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
+        public Task DeleteOriginalResponseAsync()
+            =>  this.Discord.ApiClient.DeleteOriginalInteractionResponseAsync(this.Discord.CurrentApplication.Id, this.Token);
 
         /// <summary>
         /// Creates a follow up message to this interaction.
         /// </summary>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The created <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> CreateFollowupMessageAsync(DiscordFollowupMessageBuilder builder)
         {
             builder.Validate();
 
             return await this.Discord.ApiClient.CreateFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Gets a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
-        public Task<DiscordMessage> GetFollowupMessageAsync(ulong messageId) =>
-            this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
+        public Task<DiscordMessage> GetFollowupMessageAsync(ulong messageId)
+            => this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
 
         /// <summary>
         /// Edits a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
         /// <param name="builder">The webhook builder.</param>
         /// <returns>The edited <see cref="DiscordMessage"/>.</returns>
         public async Task<DiscordMessage> EditFollowupMessageAsync(ulong messageId, DiscordWebhookBuilder builder)
         {
             builder.Validate(isFollowup: true);
 
             if (builder._keepAttachments.HasValue && builder._keepAttachments.Value)
             {
                 var attachments = this.Discord.ApiClient.GetFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId).Result.Attachments;
                 if (attachments?.Count > 0)
                 {
                     builder._attachments.AddRange(attachments);
                 }
             }
             else if (builder._keepAttachments.HasValue)
             {
                 builder._attachments.Clear();
             }
 
             return await this.Discord.ApiClient.EditFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId, builder).ConfigureAwait(false);
         }
 
         /// <summary>
         /// Deletes a follow up message.
         /// </summary>
         /// <param name="messageId">The id of the follow up message.</param>
-        public Task DeleteFollowupMessageAsync(ulong messageId) =>
-            this.Discord.ApiClient.DeleteFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
+        public Task DeleteFollowupMessageAsync(ulong messageId)
+            => this.Discord.ApiClient.DeleteFollowupMessageAsync(this.Discord.CurrentApplication.Id, this.Token, messageId);
     }
 }