feat(rest): add direct execution fast path for interaction callbacks

Interaction callbacks have a 3-second Discord deadline that makes bucket
worker queueing overhead unacceptable. Add ExecuteDirectAsync to
RestClient that bypasses the worker queue and sends immediately via
SendAndParseAsync, failing on any error without retries.

Wire CreateInteractionResponseAsync, CreateInteractionModalResponseAsync,
and CreateInteractionIframeResponseAsync to use the new direct path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Lulalaby

DisCatSharp/Net/Rest/DiscordApiClient.cs

@@ -291,6 +291,31 @@ internal Task<RestResponse> DoRequestAsync(BaseDiscordClient client, RateLimitBu
 		return req.WaitForCompletionAsync();
 	}
 
+	/// <summary>
+	///     Executes a rest request directly, bypassing the bucket worker queue.
+	///     Used for latency-sensitive endpoints like interaction callbacks.
+	/// </summary>
+	/// <param name="client">The client.</param>
+	/// <param name="bucket">The bucket.</param>
+	/// <param name="url">The url.</param>
+	/// <param name="method">The method.</param>
+	/// <param name="route">The route.</param>
+	/// <param name="headers">The headers.</param>
+	/// <param name="payload">The payload.</param>
+	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
+	/// <param name="cancellationToken">A token to cancel the request.</param>
+	internal Task<RestResponse> DoDirectRequestAsync(BaseDiscordClient client, RateLimitBucket bucket, Uri url, RestRequestMethod method, string route, IReadOnlyDictionary<string, string>? headers = null, string? payload = null, double? ratelimitWaitOverride = null, CancellationToken cancellationToken = default)
+	{
+		var req = new RestRequest(client, bucket, url, method, route, headers, payload, ratelimitWaitOverride, cancellationToken: cancellationToken);
+
+		if (this.Discord is not null)
+			this.Rest.ExecuteDirectAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, $"Error while executing direct request. Url: {url.AbsoluteUri}");
+		else
+			_ = this.Rest.ExecuteDirectAsync(req);
+
+		return req.WaitForCompletionAsync();
+	}
+
 	/// <summary>
 	///     Builds a CSV file for target users from the provided user ids.
 	/// </summary>
@@ -518,6 +543,47 @@ private Task<RestResponse> DoMultipartAsync(
 		return req.WaitForCompletionAsync();
 	}
 
+	/// <summary>
+	///     Executes a multipart request directly, bypassing the bucket worker queue.
+	///     Used for latency-sensitive endpoints like interaction callbacks with file uploads.
+	/// </summary>
+	/// <param name="client">The client.</param>
+	/// <param name="bucket">The bucket.</param>
+	/// <param name="url">The url.</param>
+	/// <param name="method">The method.</param>
+	/// <param name="route">The route.</param>
+	/// <param name="headers">The headers.</param>
+	/// <param name="values">The values.</param>
+	/// <param name="files">The files.</param>
+	/// <param name="ratelimitWaitOverride">The ratelimit wait override.</param>
+	/// <param name="overwriteFileIdStart">The file id start to overwrite.</param>
+	/// <param name="fileFieldNameFactory">The factory function to generate file field names.</param>
+	/// <param name="cancellationToken">A token to cancel the request.</param>
+	private Task<RestResponse> DoDirectMultipartAsync(
+		BaseDiscordClient client,
+		RateLimitBucket bucket,
+		Uri url,
+		RestRequestMethod method,
+		string route,
+		IReadOnlyDictionary<string, string>? headers = null,
+		IReadOnlyDictionary<string, string>? values = null,
+		IEnumerable<DiscordMessageFile>? files = null,
+		double? ratelimitWaitOverride = null,
+		int? overwriteFileIdStart = null,
+		Func<int, string>? fileFieldNameFactory = null,
+		CancellationToken cancellationToken = default
+	)
+	{
+		var req = new MultipartWebRequest(client, bucket, url, method, route, headers, values, files, ratelimitWaitOverride, overwriteFileIdStart, fileFieldNameFactory, cancellationToken);
+
+		if (this.Discord is not null)
+			this.Rest.ExecuteDirectAsync(req).LogTaskFault(this.Discord.Logger, LogLevel.Error, LoggerEvents.RestError, "Error while executing direct request");
+		else
+			_ = this.Rest.ExecuteDirectAsync(req);
+
+		return req.WaitForCompletionAsync();
+	}
+
 	/// <summary>
 	///     Executes a multipart request.
 	/// </summary>
@@ -8104,14 +8170,14 @@ internal async Task<DiscordInteractionCallbackResponse> CreateInteractionRespons
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "false").AddParameter("with_response", "true").Build();
 		if (builder is not null && builder.Files is not null && values.Count is not 0)
 		{
-			response = await this.DoMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files, cancellationToken: cancellationToken).ConfigureAwait(false);
+			response = await this.DoDirectMultipartAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, values: values, files: builder.Files, cancellationToken: cancellationToken).ConfigureAwait(false);
 
 			if (builder.Files is not null)
 				foreach (var file in builder.Files.Where(x => x.ResetPositionTo.HasValue))
 					file.Stream.Position = file.ResetPositionTo!.Value;
 		}
 		else
-			response = await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
+			response = await this.DoDirectRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
 
 		return response.ResponseCode is not HttpStatusCode.NoContent && !string.IsNullOrEmpty(response.Response)
 			? DiscordJson.DeserializeObject<DiscordInteractionCallbackResponse>(response.Response, this.Discord)
@@ -8155,7 +8221,7 @@ internal async Task CreateInteractionModalResponseAsync(ulong interactionId, str
 		}, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
-		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
+		await this.DoDirectRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
 	}
 
 	/// <summary>
@@ -8193,7 +8259,7 @@ internal async Task CreateInteractionIframeResponseAsync(ulong interactionId, st
 		}, out var path);
 
 		var url = Utilities.GetApiUriBuilderFor(path, this.Discord.Configuration).AddParameter("wait", "true").Build();
-		await this.DoRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
+		await this.DoDirectRequestAsync(this.Discord, bucket, url, RestRequestMethod.POST, route, payload: DiscordJson.SerializeObject(pld), cancellationToken: cancellationToken).ConfigureAwait(false);
 	}
 
 	/// <summary>

DisCatSharp/Net/Rest/RestClient.cs

@@ -192,6 +192,38 @@ public async Task ExecuteRequestAsync(BaseRestRequest request)
 		await request.WaitForCompletionAsync().ConfigureAwait(false);
 	}
 
+	/// <summary>
+	///     Executes a request directly without going through the bucket worker queue.
+	///     Used for latency-sensitive endpoints (e.g., interaction callbacks) where
+	///     the 3-second Discord response deadline makes queueing overhead unacceptable.
+	///     On any failure (rate limit, transient, server error), the request is failed
+	///     immediately without retries.
+	/// </summary>
+	/// <param name="request">The request to execute directly.</param>
+	internal async Task ExecuteDirectAsync(BaseRestRequest request)
+	{
+		ArgumentNullException.ThrowIfNull(request);
+
+		if (this._disposed)
+		{
+			request.SetFaulted(new ObjectDisposedException(nameof(RestClient), "Cannot execute request on a disposed RestClient."));
+			request.CancellationTokenSource.Dispose();
+			return;
+		}
+
+		var result = await this.SendAndParseAsync(request, isProbe: false, request.CancellationTokenSource.Token).ConfigureAwait(false);
+
+		if (result.Error is not null)
+		{
+			request.SetFaulted(result.Error);
+			this.ReportDiagnostics(request, result.Response!, result.Error);
+		}
+		else
+		{
+			request.SetCompleted(result.Response!);
+		}
+	}
+
 	/// <summary>
 	///     Executes the form data request by enqueuing it into the appropriate bucket worker.
 	///     Form and regular requests share the same queue/worker infrastructure.