@minesa-org/mini-interaction 0.2.21 → 0.2.23

package/dist/clients/MiniInteraction.js

@@ -1370,8 +1370,13 @@ export class MiniInteraction {
      * Includes retry logic to handle race conditions where the ACK hasn't reached Discord yet.
      */
     async sendFollowUp(token, response, messageId = "@original", retryCount = 0) {
-        const MAX_RETRIES = 3;
-        const BASE_DELAY_MS = 250; // Start with 250ms delay
+        const MAX_RETRIES = 5;
+        const BASE_DELAY_MS = 200; // Start with 200ms delay
+        const INITIAL_DELAY_MS = 100; // Wait for ACK to propagate to Discord
+        // On first attempt, add a small delay to allow ACK to propagate
+        if (retryCount === 0) {
+            await new Promise(resolve => setTimeout(resolve, INITIAL_DELAY_MS));
+        }
         const isEdit = messageId !== "";
         const url = isEdit
             ? `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}/messages/${messageId}`
@@ -1401,7 +1406,7 @@ export class MiniInteraction {
                 const errorBody = await fetchResponse.text();
                 // Check for "Unknown Webhook" error (10015) - this means ACK hasn't reached Discord yet
                 if (fetchResponse.status === 404 && errorBody.includes("10015") && retryCount < MAX_RETRIES) {
-                    const delayMs = BASE_DELAY_MS * Math.pow(2, retryCount); // Exponential backoff: 250, 500, 1000ms
+                    const delayMs = BASE_DELAY_MS * Math.pow(2, retryCount); // Exponential backoff: 200, 400, 800, 1600, 3200ms
                     console.warn(`[MiniInteraction] Webhook not ready yet, retrying in ${delayMs}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`);
                     await new Promise(resolve => setTimeout(resolve, delayMs));
                     return this.sendFollowUp(token, response, messageId, retryCount + 1);
@@ -1583,13 +1588,16 @@ function resolveOAuthConfig(provided) {
 }
 /**
  * Wraps a handler function with timeout detection and error handling.
+ *
+ * CRITICAL FOR HTTP INTERACTIONS:
+ * When deferReply() is called, we MUST return the ACK to Discord immediately.
+ * The handler continues executing and sends follow-up via webhook.
+ * The ACK must reach Discord before any webhook PATCH requests can succeed.
  */
 function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings = true, ackPromise) {
     return async (...args) => {
         const startTime = Date.now();
         let timeoutId;
-        let ackResult = null;
-        let ackReceived = false;
         const timeoutPromise = new Promise((_, reject) => {
             timeoutId = setTimeout(() => {
                 const elapsed = Date.now() - startTime;
@@ -1597,55 +1605,54 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
                 reject(new Error(`Handler timeout: ${handlerName} exceeded ${timeoutMs}ms limit`));
             }, timeoutMs);
         });
-        // If we have an ackPromise, listen for it but DON'T return early
-        // Instead, capture the ACK result and continue waiting for handler
+        // Start handler execution immediately (don't await yet)
+        const handlerPromise = Promise.resolve(handler(...args));
+        // If we have an ackPromise, race between ACK and timeout
+        // When ACK is received, return IMMEDIATELY so Discord gets the response
+        // Handler continues in background
         if (ackPromise) {
-            ackPromise.then((result) => {
-                ackResult = result;
-                ackReceived = true;
-                // Clear the timeout once we have an ACK - handler can now take longer
+            try {
+                const ackResult = await Promise.race([
+                    ackPromise,
+                    timeoutPromise,
+                ]);
+                // ACK received! Clear timeout and return immediately
                 if (timeoutId) {
                     clearTimeout(timeoutId);
-                    timeoutId = undefined;
                 }
-            }).catch(() => {
-                // ACK promise rejection is fine, we'll use handler result
-            });
+                // Handler continues in background - attach error handler
+                handlerPromise.catch((error) => {
+                    console.error(`[MiniInteraction] ${handlerName} background execution failed:`, error instanceof Error ? error.message : String(error));
+                });
+                return ackResult;
+            }
+            catch (error) {
+                // Timeout occurred before ACK - fall through to check handler
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                throw error;
+            }
         }
+        // No ACK promise - wait for handler with timeout
         try {
-            // ALWAYS wait for handler to complete
             const handlerResult = await Promise.race([
-                handler(...args),
+                handlerPromise,
                 timeoutPromise,
             ]);
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
             const elapsed = Date.now() - startTime;
-            if (enableWarnings && elapsed > timeoutMs * 0.8 && !ackReceived) {
+            if (enableWarnings && elapsed > timeoutMs * 0.8) {
                 console.warn(`[MiniInteraction] ${handlerName} completed in ${elapsed}ms (${Math.round((elapsed / timeoutMs) * 100)}% of timeout limit)`);
             }
-            // If we got an ACK, return that for the HTTP response
-            // The handler has completed at this point so all background work is done
-            if (ackReceived && ackResult !== null) {
-                return ackResult;
-            }
             return handlerResult;
         }
         catch (error) {
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
-            // If handler timed out but we have an ACK, return the ACK
-            // This allows deferReply to work even if later operations are slow
-            if (error instanceof Error && error.message.includes("Handler timeout")) {
-                if (ackReceived && ackResult !== null) {
-                    console.warn(`[MiniInteraction] ${handlerName} timed out but ACK was already captured. ` +
-                        `Background work may not complete in serverless environments.`);
-                    return ackResult;
-                }
-                throw error;
-            }
             console.error(`[MiniInteraction] ${handlerName} failed:`, error);
             throw error;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minesa-org/mini-interaction",
-	"version": "0.2.21",
+	"version": "0.2.23",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",