@minesa-org/mini-interaction 0.2.3 → 0.2.5

package/dist/clients/MiniInteraction.d.ts

@@ -49,15 +49,6 @@ export type InteractionTimeoutConfig = {
     /** Whether to enable debug logging for interaction responses (default: false) */
     enableResponseDebugLogging?: boolean;
 };
-/** Enhanced timeout configuration with response acknowledgment settings. */
-export type InteractionTimeoutConfigV2 = InteractionTimeoutConfig & {
-    /** Time to wait for Discord acknowledgment after sending response (default: 500ms) */
-    responseAcknowledgmentTimeout?: number;
-    /** Maximum retries for response acknowledgment (default: 2) */
-    responseAcknowledgmentRetries?: number;
-    /** Delay between acknowledgment retries (default: 100ms) */
-    responseAcknowledgmentRetryDelay?: number;
-};
 /** Handler signature invoked for Discord button interactions. */
 export type ButtonComponentHandler = (interaction: ButtonInteraction) => Promise<APIInteractionResponse | void> | APIInteractionResponse | void;
 /** Handler signature invoked for Discord string select menu interactions. */
@@ -184,46 +175,15 @@ export declare class MiniInteraction {
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
     constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, utilsDirectory, fetchImplementation, verifyKeyImplementation, timeoutConfig, }: InteractionClientOptions);
-    /**
-     * Tracks the state of an interaction to prevent race conditions and double responses.
-     */
     private trackInteractionState;
     /**
      * Checks if an interaction can still respond (not expired and not already responded).
      */
     private canRespond;
-    /**
-     * Logs response timing and acknowledgment for debugging.
-     */
-    private logResponseTiming;
-    /**
-     * Simulates waiting for Discord acknowledgment to help debug timing issues.
-     * Note: This is a best-effort simulation since actual acknowledgment happens at the HTTP level.
-     */
-    private simulateAcknowledgmentWait;
-    /**
-     * Enables or disables debug logging for interaction responses and timing.
-     * Useful for troubleshooting "didn't respond in time" errors.
-     *
-     * @param enabled - Whether to enable debug logging
-     */
-    setResponseDebugLogging(enabled: boolean): void;
     /**
      * Gets the current state of an interaction.
      */
     private getInteractionState;
-    /**
-     * Gets the current state of an interaction for debugging purposes.
-     *
-     * @param interactionId - The interaction ID to check
-     * @returns The current interaction state or null if not found
-     */
-    getInteractionStateInfo(interactionId: string): {
-        state: "pending" | "deferred" | "responded" | "expired";
-        timestamp: number;
-        token: string;
-        responseCount: number;
-    } | null;
     /**
      * Clears expired interaction states to prevent memory leaks.
      * Call this periodically to clean up old interaction data.
@@ -434,5 +394,10 @@ export declare class MiniInteraction {
      * Handles execution of an application command interaction.
      */
     private handleApplicationCommand;
+    /**
+     * 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).
+     */
+    private sendFollowUp;
 }
 export {};

package/dist/clients/MiniInteraction.js

@@ -78,27 +78,16 @@ export class MiniInteraction {
             enableTimeoutWarnings: true,
             autoDeferSlowOperations: true,
             enableResponseDebugLogging: false,
-            responseAcknowledgmentTimeout: 500, // 500ms to wait for acknowledgment
-            responseAcknowledgmentRetries: 2,
-            responseAcknowledgmentRetryDelay: 100,
             ...timeoutConfig,
         };
     }
-    /**
-     * Tracks the state of an interaction to prevent race conditions and double responses.
-     */
     trackInteractionState(interactionId, token, state) {
-        const existing = this.interactionStates.get(interactionId);
         const now = Date.now();
         this.interactionStates.set(interactionId, {
             state,
             timestamp: now,
             token,
-            responseCount: existing ? existing.responseCount + 1 : 1,
         });
-        if (this.timeoutConfig.enableResponseDebugLogging) {
-            console.log(`[MiniInteraction:DEBUG] Interaction ${interactionId} state: ${state} (${existing ? existing.responseCount + 1 : 1} responses)`);
-        }
     }
     /**
      * Checks if an interaction can still respond (not expired and not already responded).
@@ -118,68 +107,12 @@ export class MiniInteraction {
         }
         return true;
     }
-    /**
-     * Logs response timing and acknowledgment for debugging.
-     */
-    logResponseTiming(interactionId, operation, startTime, success) {
-        if (!this.timeoutConfig.enableResponseDebugLogging)
-            return;
-        const elapsed = Date.now() - startTime;
-        const status = success ? 'SUCCESS' : 'FAILED';
-        console.log(`[MiniInteraction:DEBUG] ${operation} for interaction ${interactionId}: ${status} (${elapsed}ms)`);
-        if (success && elapsed > 2000) {
-            console.warn(`[MiniInteraction:WARN] ${operation} took ${elapsed}ms - consider using deferReply() for slow operations`);
-        }
-    }
-    /**
-     * Simulates waiting for Discord acknowledgment to help debug timing issues.
-     * Note: This is a best-effort simulation since actual acknowledgment happens at the HTTP level.
-     */
-    async simulateAcknowledgmentWait(interactionId, operation) {
-        if (!this.timeoutConfig.enableResponseDebugLogging)
-            return;
-        const timeout = this.timeoutConfig.responseAcknowledgmentTimeout || 500;
-        const retries = this.timeoutConfig.responseAcknowledgmentRetries || 2;
-        const retryDelay = this.timeoutConfig.responseAcknowledgmentRetryDelay || 100;
-        console.log(`[MiniInteraction:DEBUG] Waiting for acknowledgment of ${operation} for interaction ${interactionId}...`);
-        for (let attempt = 0; attempt <= retries; attempt++) {
-            await new Promise(resolve => setTimeout(resolve, attempt === 0 ? timeout : retryDelay));
-            // In a real implementation, this would verify Discord actually received the response
-            // For now, we just simulate the wait time
-            const state = this.getInteractionState(interactionId);
-            if (state?.state === 'responded' || state?.state === 'deferred') {
-                console.log(`[MiniInteraction:DEBUG] Acknowledgment confirmed for ${operation} after ${attempt + 1} attempts`);
-                return;
-            }
-        }
-        console.warn(`[MiniInteraction:WARN] Acknowledgment timeout for ${operation} on interaction ${interactionId}`);
-    }
-    /**
-     * Enables or disables debug logging for interaction responses and timing.
-     * Useful for troubleshooting "didn't respond in time" errors.
-     *
-     * @param enabled - Whether to enable debug logging
-     */
-    setResponseDebugLogging(enabled) {
-        this.timeoutConfig.enableResponseDebugLogging = enabled;
-        console.log(`[MiniInteraction] Response debug logging ${enabled ? 'enabled' : 'disabled'}`);
-    }
     /**
      * Gets the current state of an interaction.
      */
     getInteractionState(interactionId) {
         return this.interactionStates.get(interactionId);
     }
-    /**
-     * Gets the current state of an interaction for debugging purposes.
-     *
-     * @param interactionId - The interaction ID to check
-     * @returns The current interaction state or null if not found
-     */
-    getInteractionStateInfo(interactionId) {
-        const state = this.interactionStates.get(interactionId);
-        return state ? { ...state } : null; // Return a copy to prevent external modification
-    }
     /**
      * Clears expired interaction states to prevent memory leaks.
      * Call this periodically to clean up old interaction data.
@@ -194,9 +127,6 @@ export class MiniInteraction {
                 cleaned++;
             }
         }
-        if (cleaned > 0) {
-            console.log(`[MiniInteraction] Cleaned up ${cleaned} expired interactions`);
-        }
         return cleaned;
     }
     normalizeCommandData(data) {
@@ -530,10 +460,6 @@ export class MiniInteraction {
                 `This may cause "didn't respond in time" errors. ` +
                 `Consider optimizing or using deferReply() for slow operations.`);
         }
-        // Log successful response timing for debugging
-        if (this.timeoutConfig.enableResponseDebugLogging) {
-            console.log(`[MiniInteraction:DEBUG] Request completed in ${totalProcessingTime}ms`);
-        }
         return {
             status: 400,
             body: {
@@ -1194,8 +1120,18 @@ export class MiniInteraction {
             };
         }
         try {
-            const interactionWithHelpers = createMessageComponentInteraction(interaction);
-            // Wrap component handler with timeout
+            // Create an acknowledgment promise that resolves when the handler calls reply() or deferReply()
+            let ackResolver = null;
+            const ackPromise = new Promise((resolve) => {
+                ackResolver = resolve;
+            });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data) => this.sendFollowUp(token, data);
+            const interactionWithHelpers = createMessageComponentInteraction(interaction, {
+                onAck: (response) => ackResolver?.(response),
+                sendFollowUp,
+            });
+            // Wrap component handler with timeout and acknowledgment
             const timeoutWrapper = createTimeoutWrapper(async () => {
                 const response = await handler(interactionWithHelpers);
                 const resolvedResponse = response ?? interactionWithHelpers.getResponse();
@@ -1204,7 +1140,7 @@ export class MiniInteraction {
                         "Return an APIInteractionResponse to acknowledge the interaction.");
                 }
                 return resolvedResponse;
-            }, this.timeoutConfig.initialResponseTimeout, `Component "${customId}"`, this.timeoutConfig.enableTimeoutWarnings);
+            }, this.timeoutConfig.initialResponseTimeout, `Component "${customId}"`, this.timeoutConfig.enableTimeoutWarnings, ackPromise);
             const resolvedResponse = await timeoutWrapper();
             return {
                 status: 200,
@@ -1249,8 +1185,18 @@ export class MiniInteraction {
             };
         }
         try {
-            const interactionWithHelpers = createModalSubmitInteraction(interaction);
-            // Wrap modal handler with timeout
+            // Create an acknowledgment promise for modals
+            let ackResolver = null;
+            const ackPromise = new Promise((resolve) => {
+                ackResolver = resolve;
+            });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data) => this.sendFollowUp(token, data);
+            const interactionWithHelpers = createModalSubmitInteraction(interaction, {
+                onAck: (response) => ackResolver?.(response),
+                sendFollowUp,
+            });
+            // Wrap modal handler with timeout and acknowledgment
             const timeoutWrapper = createTimeoutWrapper(async () => {
                 const response = await handler(interactionWithHelpers);
                 const resolvedResponse = response ?? interactionWithHelpers.getResponse();
@@ -1259,7 +1205,7 @@ export class MiniInteraction {
                         "Return an APIInteractionResponse to acknowledge the interaction.");
                 }
                 return resolvedResponse;
-            }, this.timeoutConfig.initialResponseTimeout, `Modal "${customId}"`, this.timeoutConfig.enableTimeoutWarnings);
+            }, this.timeoutConfig.initialResponseTimeout, `Modal "${customId}"`, this.timeoutConfig.enableTimeoutWarnings, ackPromise);
             const resolvedResponse = await timeoutWrapper();
             return {
                 status: 200,
@@ -1307,6 +1253,13 @@ export class MiniInteraction {
         try {
             let response;
             let resolvedResponse = null;
+            // Create an acknowledgment promise for application commands
+            let ackResolver = null;
+            const ackPromise = new Promise((resolve) => {
+                ackResolver = resolve;
+            });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data) => this.sendFollowUp(token, data);
             // Create a timeout wrapper for the command handler
             const timeoutWrapper = createTimeoutWrapper(async () => {
                 // Check if it's a chat input (slash) command
@@ -1315,7 +1268,8 @@ export class MiniInteraction {
                     const interactionWithHelpers = createCommandInteraction(commandInteraction, {
                         canRespond: (id) => this.canRespond(id),
                         trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
-                        logTiming: (id, op, start, success) => this.logResponseTiming(id, op, start, success),
+                        onAck: (response) => ackResolver?.(response),
+                        sendFollowUp,
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
@@ -1324,14 +1278,18 @@ export class MiniInteraction {
                 else if (commandInteraction.data.type ===
                     ApplicationCommandType.User) {
                     // User context menu command
-                    const interactionWithHelpers = createUserContextMenuInteraction(commandInteraction);
+                    const interactionWithHelpers = createUserContextMenuInteraction(commandInteraction, {
+                        onAck: (response) => ackResolver?.(response),
+                    });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
                         response ?? interactionWithHelpers.getResponse();
                 }
                 else if (commandInteraction.data.type ===
                     ApplicationCommandType.PrimaryEntryPoint) {
-                    const interactionWithHelpers = createAppCommandInteraction(commandInteraction);
+                    const interactionWithHelpers = createAppCommandInteraction(commandInteraction, {
+                        onAck: (response) => ackResolver?.(response),
+                    });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
                         response ?? interactionWithHelpers.getResponse();
@@ -1339,7 +1297,9 @@ export class MiniInteraction {
                 else if (commandInteraction.data.type ===
                     ApplicationCommandType.Message) {
                     // Message context menu command
-                    const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction);
+                    const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction, {
+                        onAck: (response) => ackResolver?.(response),
+                    });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
                         response ?? interactionWithHelpers.getResponse();
@@ -1349,9 +1309,10 @@ export class MiniInteraction {
                     response = await command.handler(commandInteraction);
                     resolvedResponse = response ?? null;
                 }
-            }, this.timeoutConfig.initialResponseTimeout, `Command "${commandName}"`, this.timeoutConfig.enableTimeoutWarnings);
-            await timeoutWrapper();
-            if (!resolvedResponse) {
+                return resolvedResponse;
+            }, this.timeoutConfig.initialResponseTimeout, `Command "${commandName}"`, this.timeoutConfig.enableTimeoutWarnings, ackPromise);
+            const finalResponse = await timeoutWrapper();
+            if (!finalResponse) {
                 console.error(`[MiniInteraction] Command "${commandName}" did not return a response. ` +
                     "This indicates the handler completed but no response was generated. " +
                     "Check that deferReply(), reply(), showModal(), or a direct response is returned.");
@@ -1366,7 +1327,7 @@ export class MiniInteraction {
             }
             return {
                 status: 200,
-                body: resolvedResponse,
+                body: finalResponse,
             };
         }
         catch (error) {
@@ -1386,6 +1347,33 @@ 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).
+     */
+    async sendFollowUp(token, response) {
+        const url = `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}/messages/@original`;
+        // Only send follow-up if there is data to send
+        if (!('data' in response) || !response.data) {
+            return;
+        }
+        try {
+            const fetchResponse = await this.fetchImpl(url, {
+                method: "PATCH",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(response.data),
+            });
+            if (!fetchResponse.ok) {
+                const errorBody = await fetchResponse.text();
+                console.error(`[MiniInteraction] Failed to send follow-up response: [${fetchResponse.status}] ${errorBody}`);
+            }
+        }
+        catch (error) {
+            console.error(`[MiniInteraction] Error sending follow-up response: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }
 const DEFAULT_DISCORD_OAUTH_TEMPLATES = {
     success: ({ user }) => {
@@ -1554,7 +1542,7 @@ function resolveOAuthConfig(provided) {
 /**
  * Wraps a handler function with timeout detection and error handling.
  */
-function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings = true) {
+function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings = true, ackPromise) {
     return async (...args) => {
         const startTime = Date.now();
         let timeoutId;
@@ -1566,10 +1554,14 @@ function createTimeoutWrapper(handler, timeoutMs, handlerName, enableWarnings =
             }, timeoutMs);
         });
         try {
-            const result = await Promise.race([
+            const promises = [
                 Promise.resolve(handler(...args)),
                 timeoutPromise,
-            ]);
+            ];
+            if (ackPromise) {
+                promises.push(ackPromise);
+            }
+            const result = await Promise.race(promises);
             if (timeoutId) {
                 clearTimeout(timeoutId);
             }

package/dist/database/MiniDatabase.js

@@ -77,7 +77,6 @@ export class MiniDatabase {
             await this.mongoClient.connect();
             this.mongoDb = this.mongoClient.db(this.config.dbName || "minidb");
             this.mongoCollection = this.mongoDb.collection(this.config.collectionName || "data");
-            console.log("✅ [MiniDatabase] Connected to MongoDB");
         }
         catch (err) {
             console.error("❌ [MiniDatabase] Failed to connect to MongoDB:", err);
@@ -136,7 +135,6 @@ export class MiniDatabase {
                     createdAt: new Date(),
                 },
             }, { upsert: true });
-            console.log(`✅ [MiniDatabase] Saved data for key "${key}"`);
             return true;
         }
         catch (err) {
@@ -175,7 +173,6 @@ export class MiniDatabase {
                     createdAt: new Date(),
                 },
             }, { upsert: true });
-            console.log(`✅ [MiniDatabase] Updated data for key "${key}"`);
             return true;
         }
         catch (err) {
@@ -194,7 +191,6 @@ export class MiniDatabase {
                 throw new Error("MongoDB collection is not initialized");
             }
             await collection.deleteOne({ _id: key });
-            console.log(`✅ [MiniDatabase] Deleted data for key "${key}"`);
             return true;
         }
         catch (err) {
@@ -208,7 +204,6 @@ export class MiniDatabase {
     async close() {
         if (this.mongoClient) {
             await this.mongoClient.close();
-            console.log("✅ [MiniDatabase] MongoDB connection closed");
         }
     }
 }

package/dist/utils/CommandInteractionOptions.d.ts

@@ -154,7 +154,8 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     withTimeoutProtection<T>(operation: () => Promise<T>, deferOptions?: DeferReplyOptions): Promise<T>;
     canRespond?(interactionId: string): boolean;
     trackResponse?(interactionId: string, token: string, state: 'responded' | 'deferred'): void;
-    logTiming?(interactionId: string, operation: string, startTime: number, success: boolean): void;
+    onAck?(response: APIInteractionResponse): void;
+    sendFollowUp?(token: string, response: APIInteractionResponse): void;
 }
 export declare const CommandInteraction: {};
 /**
@@ -168,4 +169,6 @@ export declare function createCommandInteraction(interaction: APIChatInputApplic
     canRespond?: (interactionId: string) => boolean;
     trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
     logTiming?: (interactionId: string, operation: string, startTime: number, success: boolean) => void;
+    onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
 }): CommandInteraction;

package/dist/utils/CommandInteractionOptions.js

@@ -379,16 +379,19 @@ export function createCommandInteraction(interaction, helpers) {
             if (!this.canRespond?.(this.id)) {
                 throw new Error('Interaction cannot respond: already responded or expired');
             }
-            const startTime = Date.now();
             const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
             // Track response
             this.trackResponse?.(this.id, this.token, 'responded');
-            // Log timing if debug enabled
-            this.logTiming?.(this.id, 'reply', startTime, true);
+            // Notify acknowledgment
+            this.onAck?.(response);
             return response;
         },
         followUp(data) {
-            return createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+            const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+            if (this.sendFollowUp) {
+                this.sendFollowUp(this.token, response);
+            }
+            return response;
         },
         edit(data) {
             return createMessageResponse(InteractionResponseType.UpdateMessage, data);
@@ -398,12 +401,13 @@ export function createCommandInteraction(interaction, helpers) {
             if (!this.canRespond?.(this.id)) {
                 throw new Error('Interaction cannot edit reply: already responded, expired, or not deferred');
             }
-            const startTime = Date.now();
             const response = createMessageResponse(InteractionResponseType.UpdateMessage, data);
+            // If it's already deferred or responded, we MUST use a webhook
+            if (this.sendFollowUp) {
+                this.sendFollowUp(this.token, response);
+            }
             // Track response
             this.trackResponse?.(this.id, this.token, 'responded');
-            // Log timing if debug enabled
-            this.logTiming?.(this.id, 'editReply', startTime, true);
             return response;
         },
         deferReply(options) {
@@ -411,14 +415,13 @@ export function createCommandInteraction(interaction, helpers) {
             if (!this.canRespond?.(this.id)) {
                 throw new Error('Interaction cannot defer: already responded or expired');
             }
-            const startTime = Date.now();
             const response = createDeferredResponse(options?.flags !== undefined
                 ? { flags: options.flags }
                 : undefined);
             // Track deferred state
             this.trackResponse?.(this.id, this.token, 'deferred');
-            // Log timing if debug enabled
-            this.logTiming?.(this.id, 'deferReply', startTime, true);
+            // Notify acknowledgment
+            this.onAck?.(response);
             return response;
         },
         showModal(data) {
@@ -469,7 +472,7 @@ export function createCommandInteraction(interaction, helpers) {
         // Helper methods for state management
         canRespond: helpers?.canRespond,
         trackResponse: helpers?.trackResponse,
-        logTiming: helpers?.logTiming,
+        onAck: helpers?.onAck,
     };
     return commandInteraction;
 }

package/dist/utils/ContextMenuInteraction.d.ts

@@ -12,6 +12,7 @@ type ContextMenuInteractionHelpers = {
     showModal: (data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
     }) => APIModalInteractionResponse;
+    onAck?: (response: APIInteractionResponse) => void;
 };
 /**
  * User context menu interaction with helper methods.
@@ -40,19 +41,25 @@ export declare const AppCommandInteraction: {};
  * @param interaction - The raw user context menu interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export declare function createUserContextMenuInteraction(interaction: APIUserApplicationCommandInteraction): UserContextMenuInteraction;
+export declare function createUserContextMenuInteraction(interaction: APIUserApplicationCommandInteraction, helpers?: {
+    onAck?: (response: APIInteractionResponse) => void;
+}): UserContextMenuInteraction;
 /**
  * Wraps a raw message context menu interaction with helper methods.
  *
  * @param interaction - The raw message context menu interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export declare function createMessageContextMenuInteraction(interaction: APIMessageApplicationCommandInteraction): MessageContextMenuInteraction;
+export declare function createMessageContextMenuInteraction(interaction: APIMessageApplicationCommandInteraction, helpers?: {
+    onAck?: (response: APIInteractionResponse) => void;
+}): MessageContextMenuInteraction;
 /**
  * Wraps a raw primary entry point interaction with helper methods.
  *
  * @param interaction - The raw primary entry point interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export declare function createAppCommandInteraction(interaction: APIPrimaryEntryPointCommandInteraction): AppCommandInteraction;
+export declare function createAppCommandInteraction(interaction: APIPrimaryEntryPointCommandInteraction, helpers?: {
+    onAck?: (response: APIInteractionResponse) => void;
+}): AppCommandInteraction;
 export {};

package/dist/utils/ContextMenuInteraction.js

@@ -3,7 +3,7 @@ import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./inter
 export const UserContextMenuInteraction = {};
 export const MessageContextMenuInteraction = {};
 export const AppCommandInteraction = {};
-function createContextMenuInteractionHelpers() {
+function createContextMenuInteractionHelpers(helpers) {
     let capturedResponse = null;
     const captureResponse = (response) => {
         capturedResponse = response;
@@ -25,15 +25,21 @@ function createContextMenuInteractionHelpers() {
         }
         return captureResponse({ type });
     }
-    const reply = (data) => createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+    const reply = (data) => {
+        const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+        helpers?.onAck?.(response);
+        return response;
+    };
     const followUp = (data) => createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
     const editReply = (data) => createMessageResponse(InteractionResponseType.UpdateMessage, data);
     const deferReply = (options = {}) => {
         const flags = normaliseMessageFlags(options.flags);
-        return captureResponse({
+        const response = captureResponse({
             type: InteractionResponseType.DeferredChannelMessageWithSource,
             data: flags ? { flags } : undefined,
         });
+        helpers?.onAck?.(response);
+        return response;
     };
     const showModal = (data) => {
         const modalData = typeof data === "object" && "toJSON" in data ? data.toJSON() : data;
@@ -50,6 +56,7 @@ function createContextMenuInteractionHelpers() {
         editReply,
         deferReply,
         showModal,
+        onAck: helpers?.onAck,
     };
 }
 /**
@@ -58,8 +65,8 @@ function createContextMenuInteractionHelpers() {
  * @param interaction - The raw user context menu interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export function createUserContextMenuInteraction(interaction) {
-    return Object.assign(interaction, createContextMenuInteractionHelpers(), {
+export function createUserContextMenuInteraction(interaction, helpers) {
+    return Object.assign(interaction, createContextMenuInteractionHelpers(helpers), {
         targetUser: resolveTargetUser(interaction),
     });
 }
@@ -69,8 +76,8 @@ export function createUserContextMenuInteraction(interaction) {
  * @param interaction - The raw message context menu interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export function createMessageContextMenuInteraction(interaction) {
-    return Object.assign(interaction, createContextMenuInteractionHelpers(), {
+export function createMessageContextMenuInteraction(interaction, helpers) {
+    return Object.assign(interaction, createContextMenuInteractionHelpers(helpers), {
         targetMessage: resolveTargetMessage(interaction),
     });
 }
@@ -80,8 +87,8 @@ export function createMessageContextMenuInteraction(interaction) {
  * @param interaction - The raw primary entry point interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export function createAppCommandInteraction(interaction) {
-    return Object.assign(interaction, createContextMenuInteractionHelpers());
+export function createAppCommandInteraction(interaction, helpers) {
+    return Object.assign(interaction, createContextMenuInteractionHelpers(helpers));
 }
 function resolveTargetMessage(interaction) {
     const targetId = interaction.data?.target_id;

package/dist/utils/MessageComponentInteraction.d.ts

@@ -27,6 +27,8 @@ type BaseComponentInteractionHelpers = {
     showModal: (data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
     }) => APIModalInteractionResponse;
+    onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
 };
 /**
  * Button interaction with helper methods.
@@ -96,6 +98,11 @@ export type MessageComponentInteraction = APIMessageComponentInteraction & {
     showModal: (data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
     }) => APIModalInteractionResponse;
+    /**
+     * Finalise the interaction response via a webhook follow-up.
+     * This is automatically called by reply() and update() if the interaction is deferred.
+     */
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
     /**
      * The selected values from a select menu interaction.
      * This property is only present for select menu interactions.
@@ -135,5 +142,8 @@ export declare const MessageComponentInteraction: {};
  * @param interaction - The raw interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export declare function createMessageComponentInteraction(interaction: APIMessageComponentInteraction): MessageComponentInteraction;
+export declare function createMessageComponentInteraction(interaction: APIMessageComponentInteraction, helpers?: {
+    onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
+}): MessageComponentInteraction;
 export {};

package/dist/utils/MessageComponentInteraction.js

@@ -15,8 +15,9 @@ export const MessageComponentInteraction = {};
  * @param interaction - The raw interaction payload from Discord.
  * @returns A helper-augmented interaction object.
  */
-export function createMessageComponentInteraction(interaction) {
+export function createMessageComponentInteraction(interaction, helpers) {
     let capturedResponse = null;
+    let isDeferred = false;
     const captureResponse = (response) => {
         capturedResponse = response;
         return response;
@@ -26,10 +27,17 @@ export function createMessageComponentInteraction(interaction) {
         if (!normalisedData) {
             throw new Error("[MiniInteraction] Component replies require response data to be provided.");
         }
-        return captureResponse({
+        const response = captureResponse({
             type: InteractionResponseType.ChannelMessageWithSource,
             data: normalisedData,
         });
+        if (isDeferred && helpers?.sendFollowUp) {
+            helpers.sendFollowUp(interaction.token, response);
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
+        return response;
     };
     const deferReply = (options) => {
         const flags = normaliseMessageFlags(options?.flags);
@@ -41,7 +49,10 @@ export function createMessageComponentInteraction(interaction) {
             : {
                 type: InteractionResponseType.DeferredChannelMessageWithSource,
             };
-        return captureResponse(response);
+        captureResponse(response);
+        isDeferred = true;
+        helpers?.onAck?.(response);
+        return response;
     };
     const update = (data) => {
         const normalisedData = normaliseInteractionMessageData(data);
@@ -53,11 +64,19 @@ export function createMessageComponentInteraction(interaction) {
             : {
                 type: InteractionResponseType.UpdateMessage,
             };
+        if (isDeferred && helpers?.sendFollowUp) {
+            helpers.sendFollowUp(interaction.token, response);
+        }
         return captureResponse(response);
     };
-    const deferUpdate = () => captureResponse({
-        type: InteractionResponseType.DeferredMessageUpdate,
-    });
+    const deferUpdate = () => {
+        const response = captureResponse({
+            type: InteractionResponseType.DeferredMessageUpdate,
+        });
+        isDeferred = true;
+        helpers?.onAck?.(response);
+        return response;
+    };
     const showModal = (data) => {
         const resolvedData = typeof data === "object" &&
             "toJSON" in data &&
@@ -178,5 +197,7 @@ export function createMessageComponentInteraction(interaction) {
         getChannels,
         getUsers,
         getMentionables,
+        onAck: helpers?.onAck,
+        sendFollowUp: helpers?.sendFollowUp,
     });
 }

package/dist/utils/ModalSubmitInteraction.d.ts

@@ -8,28 +8,24 @@ export type ModalSubmitInteraction = APIModalSubmitInteraction & {
     reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
     /**
-     * Helper method to get the value of a text input component by custom_id.
-     * @param customId - The custom_id of the text input component
-     * @returns The value of the text input, or undefined if not found
+     * Helper method to get the value of a text input component by its custom ID.
      */
-    getTextInputValue: (customId: string) => string | undefined;
+    getTextFieldValue: (customId: string) => string | undefined;
     /**
-     * Helper method to get all text input values as a map.
-     * @returns A map of custom_id to value for all text inputs
+     * Finalise the interaction response via a webhook follow-up.
+     * This is automatically called by reply() if the interaction is deferred.
      */
-    getTextInputValues: () => Map<string, string>;
-    /**
-     * Helper method to get the selected values of a select menu component by custom_id.
-     * @param customId - The custom_id of the select menu component
-     * @returns The selected values of the select menu, or undefined if not found
-     */
-    getSelectMenuValues: (customId: string) => string[] | undefined;
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
 };
 export declare const ModalSubmitInteraction: {};
 /**
- * Wraps a raw modal submit interaction with helper methods.
+ * Wraps a raw modal submit interaction with helper methods mirroring Discord's expected responses.
  *
  * @param interaction - The raw interaction payload from Discord.
+ * @param helpers - Optional callback to capture the final interaction response.
  * @returns A helper-augmented interaction object.
  */
-export declare function createModalSubmitInteraction(interaction: APIModalSubmitInteraction): ModalSubmitInteraction;
+export declare function createModalSubmitInteraction(interaction: APIModalSubmitInteraction, helpers?: {
+    onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse) => void;
+}): ModalSubmitInteraction;

package/dist/utils/ModalSubmitInteraction.js

@@ -1,14 +1,16 @@
-import { InteractionResponseType, } from "discord-api-types/v10";
+import { ComponentType, InteractionResponseType, } from "discord-api-types/v10";
 import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./interactionMessageHelpers.js";
 export const ModalSubmitInteraction = {};
 /**
- * Wraps a raw modal submit interaction with helper methods.
+ * Wraps a raw modal submit interaction with helper methods mirroring Discord's expected responses.
  *
  * @param interaction - The raw interaction payload from Discord.
+ * @param helpers - Optional callback to capture the final interaction response.
  * @returns A helper-augmented interaction object.
  */
-export function createModalSubmitInteraction(interaction) {
+export function createModalSubmitInteraction(interaction, helpers) {
     let capturedResponse = null;
+    let isDeferred = false;
     const captureResponse = (response) => {
         capturedResponse = response;
         return response;
@@ -16,12 +18,19 @@ export function createModalSubmitInteraction(interaction) {
     const reply = (data) => {
         const normalisedData = normaliseInteractionMessageData(data);
         if (!normalisedData) {
-            throw new Error("[MiniInteraction] Modal submit replies require response data to be provided.");
+            throw new Error("[MiniInteraction] Modal replies require response data to be provided.");
         }
-        return captureResponse({
+        const response = captureResponse({
             type: InteractionResponseType.ChannelMessageWithSource,
             data: normalisedData,
         });
+        if (isDeferred && helpers?.sendFollowUp) {
+            helpers.sendFollowUp(interaction.token, response);
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
+        return response;
     };
     const deferReply = (options) => {
         const flags = normaliseMessageFlags(options?.flags);
@@ -33,67 +42,30 @@ export function createModalSubmitInteraction(interaction) {
             : {
                 type: InteractionResponseType.DeferredChannelMessageWithSource,
             };
-        return captureResponse(response);
+        captureResponse(response);
+        isDeferred = true;
+        helpers?.onAck?.(response);
+        return response;
     };
     const getResponse = () => capturedResponse;
-    // Helper to extract text input values from modal components
-    const extractTextInputs = () => {
-        const textInputs = new Map();
-        for (const component of interaction.data.components) {
-            // Handle action rows
-            if ("components" in component && Array.isArray(component.components)) {
-                for (const child of component.components) {
-                    if ("value" in child && "custom_id" in child) {
-                        textInputs.set(child.custom_id, child.value);
+    const getTextFieldValue = (customId) => {
+        for (const actionRow of interaction.data.components) {
+            if ("components" in actionRow && Array.isArray(actionRow.components)) {
+                for (const component of actionRow.components) {
+                    if (component.type === ComponentType.TextInput &&
+                        component.custom_id === customId) {
+                        return component.value;
                     }
                 }
             }
-            // Handle labeled components
-            else if ("component" in component) {
-                const labeledComponent = component.component;
-                if ("value" in labeledComponent && "custom_id" in labeledComponent) {
-                    textInputs.set(labeledComponent.custom_id, labeledComponent.value);
-                }
-            }
         }
-        return textInputs;
-    };
-    // Helper to extract select menu values from modal components
-    const extractSelectMenuValues = () => {
-        const selectMenuValues = new Map();
-        for (const component of interaction.data.components) {
-            // Handle action rows
-            if ("components" in component && Array.isArray(component.components)) {
-                for (const child of component.components) {
-                    if ("values" in child && "custom_id" in child && Array.isArray(child.values)) {
-                        selectMenuValues.set(child.custom_id, child.values);
-                    }
-                }
-            }
-            // Handle labeled components (unlikely for select menus but good for completeness if spec allows)
-            else if ("component" in component) {
-                const labeledComponent = component.component; // Using any as ModalSubmitComponent might not cover select menus fully in types yet or strictness varies
-                if ("values" in labeledComponent && "custom_id" in labeledComponent && Array.isArray(labeledComponent.values)) {
-                    selectMenuValues.set(labeledComponent.custom_id, labeledComponent.values);
-                }
-            }
-        }
-        return selectMenuValues;
-    };
-    const textInputValues = extractTextInputs();
-    const selectMenuValues = extractSelectMenuValues();
-    const getTextInputValue = (customId) => {
-        return textInputValues.get(customId);
-    };
-    const getTextInputValues = () => {
-        return new Map(textInputValues);
+        return undefined;
     };
     return Object.assign(interaction, {
         reply,
         deferReply,
         getResponse,
-        getTextInputValue,
-        getTextInputValues,
-        getSelectMenuValues: (customId) => selectMenuValues.get(customId),
+        getTextFieldValue,
+        sendFollowUp: helpers?.sendFollowUp,
     });
 }

package/package.json

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