@minesa-org/mini-interaction 0.2.17 → 0.2.19

package/dist/clients/MiniInteraction.d.ts

@@ -397,6 +397,8 @@ export declare class MiniInteraction {
     /**
      * Sends a follow-up response or edits an existing response via Discord's interaction webhooks.
      * This is used for interactions that have already been acknowledged (e.g., via deferReply).
+     *
+     * Includes retry logic to handle race conditions where the ACK hasn't reached Discord yet.
      */
     private sendFollowUp;
 }

package/dist/clients/MiniInteraction.js

@@ -1366,14 +1366,18 @@ export class MiniInteraction {
     /**
      * Sends a follow-up response or edits an existing response via Discord's interaction webhooks.
      * This is used for interactions that have already been acknowledged (e.g., via deferReply).
+     *
+     * Includes retry logic to handle race conditions where the ACK hasn't reached Discord yet.
      */
-    async sendFollowUp(token, response, messageId = "@original") {
+    async sendFollowUp(token, response, messageId = "@original", retryCount = 0) {
+        const MAX_RETRIES = 3;
+        const BASE_DELAY_MS = 250; // Start with 250ms delay
         const isEdit = messageId !== "";
         const url = isEdit
             ? `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}/messages/${messageId}`
             : `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}`;
         if (this.timeoutConfig.enableResponseDebugLogging) {
-            console.log(`[MiniInteraction] sendFollowUp: id=${messageId || 'new'}, edit=${isEdit}, url=${url}`);
+            console.log(`[MiniInteraction] sendFollowUp: id=${messageId || 'new'}, edit=${isEdit}, retry=${retryCount}, url=${url}`);
         }
         // Only send follow-up if there is data to send
         if (!('data' in response) || !response.data) {
@@ -1395,6 +1399,13 @@ export class MiniInteraction {
             }
             if (!fetchResponse.ok) {
                 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
+                    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);
+                }
                 console.error(`[MiniInteraction] Failed to send follow-up response (id=${messageId || 'new'}): [${fetchResponse.status}] ${errorBody}`);
                 if (fetchResponse.status === 404) {
                     console.error("[MiniInteraction] Hint: Interaction token might have expired or the message was deleted.");
@@ -1577,6 +1588,8 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
     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;
@@ -1584,47 +1597,56 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
                 reject(new Error(`Handler timeout: ${handlerName} exceeded ${timeoutMs}ms limit`));
             }, timeoutMs);
         });
-        // Create the handler promise and handle its potential background errors
-        const handlerPromise = (async () => {
-            try {
-                return await handler(...args);
-            }
-            catch (error) {
-                // If this error happens AFTER an ACK was already sent (via ackPromise)
-                // or after a timeout, we MUST still log it because nobody else will catch it.
-                console.error(`[MiniInteraction] ${handlerName} background error:`, error);
-                throw error;
-            }
-        })();
+        // If we have an ackPromise, listen for it but DON'T return early
+        // Instead, capture the ACK result and continue waiting for handler
+        if (ackPromise) {
+            ackPromise.then((result) => {
+                ackResult = result;
+                ackReceived = true;
+                // Clear the timeout once we have an ACK - handler can now take longer
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                    timeoutId = undefined;
+                }
+            }).catch(() => {
+                // ACK promise rejection is fine, we'll use handler result
+            });
+        }
         try {
-            const promises = [
-                handlerPromise,
+            // ALWAYS wait for handler to complete
+            const handlerResult = await Promise.race([
+                handler(...args),
                 timeoutPromise,
-            ];
-            if (ackPromise) {
-                promises.push(ackPromise);
-            }
-            const result = await Promise.race(promises);
+            ]);
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }
             const elapsed = Date.now() - startTime;
-            if (enableWarnings && elapsed > timeoutMs * 0.8) {
+            if (enableWarnings && elapsed > timeoutMs * 0.8 && !ackReceived) {
                 console.warn(`[MiniInteraction] ${handlerName} completed in ${elapsed}ms (${Math.round((elapsed / timeoutMs) * 100)}% of timeout limit)`);
             }
-            return result;
+            // 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);
             }
-            // Background errors are already logged above
-            if (error instanceof Error &&
-                error.message.includes("Handler timeout")) {
+            // 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;
             }
-            // Only log here if it wasn't a background error (which we already caught)
-            // But since we catch all in handlerPromise, this is mostly for the timeout/race itself.
+            console.error(`[MiniInteraction] ${handlerName} failed:`, error);
             throw error;
         }
     };

package/package.json

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