@minesa-org/mini-interaction 0.2.4 → 0.2.6

package/dist/clients/MiniInteraction.d.ts

@@ -394,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

@@ -101,10 +101,6 @@ export class MiniInteraction {
             this.trackInteractionState(interactionId, state.token, 'expired');
             return false;
         }
-        // Check if already responded
-        if (state.state === 'responded') {
-            return false;
-        }
         return true;
     }
     /**
@@ -1125,8 +1121,11 @@ export class MiniInteraction {
             const ackPromise = new Promise((resolve) => {
                 ackResolver = resolve;
             });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data, messageId = '@original') => this.sendFollowUp(token, data, messageId);
             const interactionWithHelpers = createMessageComponentInteraction(interaction, {
                 onAck: (response) => ackResolver?.(response),
+                sendFollowUp,
             });
             // Wrap component handler with timeout and acknowledgment
             const timeoutWrapper = createTimeoutWrapper(async () => {
@@ -1187,8 +1186,11 @@ export class MiniInteraction {
             const ackPromise = new Promise((resolve) => {
                 ackResolver = resolve;
             });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data, messageId = '@original') => this.sendFollowUp(token, data, messageId);
             const interactionWithHelpers = createModalSubmitInteraction(interaction, {
                 onAck: (response) => ackResolver?.(response),
+                sendFollowUp,
             });
             // Wrap modal handler with timeout and acknowledgment
             const timeoutWrapper = createTimeoutWrapper(async () => {
@@ -1252,6 +1254,8 @@ export class MiniInteraction {
             const ackPromise = new Promise((resolve) => {
                 ackResolver = resolve;
             });
+            // Helper to send follow-up responses via webhooks
+            const sendFollowUp = (token, data, messageId = '@original') => this.sendFollowUp(token, data, messageId);
             // Create a timeout wrapper for the command handler
             const timeoutWrapper = createTimeoutWrapper(async () => {
                 // Check if it's a chat input (slash) command
@@ -1261,6 +1265,7 @@ export class MiniInteraction {
                         canRespond: (id) => this.canRespond(id),
                         trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
                         onAck: (response) => ackResolver?.(response),
+                        sendFollowUp,
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
@@ -1338,6 +1343,36 @@ 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, messageId = "@original") {
+        const isEdit = messageId !== "";
+        const url = isEdit
+            ? `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}/messages/${messageId}`
+            : `${DISCORD_BASE_URL}/webhooks/${this.applicationId}/${token}`;
+        // 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: isEdit ? "PATCH" : "POST",
+                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 }) => {

package/dist/utils/CommandInteractionOptions.d.ts

@@ -144,9 +144,9 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     options: CommandInteractionOptionResolver;
     getResponse(): APIInteractionResponse | null;
     reply(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
-    followUp(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
+    followUp(data: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource>;
     edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
-    editReply(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
+    editReply(data?: InteractionMessageData): Promise<APIInteractionResponseUpdateMessage>;
     deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
     showModal(data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;
@@ -155,6 +155,7 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     canRespond?(interactionId: string): boolean;
     trackResponse?(interactionId: string, token: string, state: 'responded' | 'deferred'): void;
     onAck?(response: APIInteractionResponse): void;
+    sendFollowUp?(token: string, response: APIInteractionResponse, messageId?: string): Promise<void>;
 }
 export declare const CommandInteraction: {};
 /**
@@ -169,4 +170,5 @@ export declare function createCommandInteraction(interaction: APIChatInputApplic
     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, messageId?: string) => Promise<void>;
 }): CommandInteraction;

package/dist/utils/CommandInteractionOptions.js

@@ -327,6 +327,8 @@ export const CommandInteraction = {};
 export function createCommandInteraction(interaction, helpers) {
     const options = new CommandInteractionOptionResolver(interaction.data.options, interaction.data.resolved);
     let capturedResponse = null;
+    let isDeferred = false;
+    let hasResponded = false;
     /**
      * Stores the most recent response helper payload for later retrieval.
      */
@@ -379,31 +381,38 @@ 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');
+            hasResponded = true;
             // Notify acknowledgment
             this.onAck?.(response);
-            // Log timing if debug enabled
             return response;
         },
-        followUp(data) {
-            return createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+        async followUp(data) {
+            const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
+            if (this.sendFollowUp) {
+                // Empty string for messageId means a new follow-up (POST)
+                await this.sendFollowUp(this.token, response, '');
+            }
+            return response;
         },
         edit(data) {
             return createMessageResponse(InteractionResponseType.UpdateMessage, data);
         },
-        editReply(data) {
+        async editReply(data) {
             // Validate interaction can respond
             if (!this.canRespond?.(this.id)) {
-                throw new Error('Interaction cannot edit reply: already responded, expired, or not deferred');
+                throw new Error('Interaction cannot edit reply: expired');
             }
-            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 && (isDeferred || hasResponded)) {
+                await this.sendFollowUp(this.token, response, '@original');
+            }
             // Track response
             this.trackResponse?.(this.id, this.token, 'responded');
-            // Log timing if debug enabled
+            hasResponded = true;
             return response;
         },
         deferReply(options) {
@@ -411,15 +420,14 @@ 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');
+            isDeferred = true;
             // Notify acknowledgment
             this.onAck?.(response);
-            // Log timing if debug enabled
             return response;
         },
         showModal(data) {

package/dist/utils/MessageComponentInteraction.d.ts

@@ -18,68 +18,110 @@ export declare const ResolvedMentionableOption: {};
 /**
  * Base helper methods available on all component interactions.
  */
-type BaseComponentInteractionHelpers = {
-    getResponse: () => APIInteractionResponse | null;
-    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
-    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
-    update: (data?: InteractionMessageData) => APIInteractionResponseUpdateMessage;
-    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
-    showModal: (data: APIModalInteractionResponseCallbackData | {
-        toJSON(): APIModalInteractionResponseCallbackData;
-    }) => APIModalInteractionResponse;
+export type BaseComponentInteractionHelpers = {
+    trackTiming?: (interactionId: string, operation: string, startTime: number, success: boolean) => void;
     onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
 };
 /**
  * Button interaction with helper methods.
  * Buttons don't have values or resolved data.
  */
-export interface ButtonInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface ButtonInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageButtonInteractionData;
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const ButtonInteraction: {};
 /**
  * String select menu interaction with helper methods.
  */
-export interface StringSelectInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface StringSelectInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageStringSelectInteractionData;
     values: string[];
     getStringValues: () => string[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const StringSelectInteraction: {};
 /**
  * Role select menu interaction with helper methods.
  */
-export interface RoleSelectInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface RoleSelectInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageRoleSelectInteractionData;
     values: string[];
     getRoles: () => APIRole[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const RoleSelectInteraction: {};
 /**
  * User select menu interaction with helper methods.
  */
-export interface UserSelectInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface UserSelectInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageUserSelectInteractionData;
     values: string[];
     getUsers: () => ResolvedUserOption[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const UserSelectInteraction: {};
 /**
  * Channel select menu interaction with helper methods.
  */
-export interface ChannelSelectInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface ChannelSelectInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageChannelSelectInteractionData;
     values: string[];
     getChannels: () => APIInteractionDataResolvedChannel[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const ChannelSelectInteraction: {};
 /**
  * Mentionable select menu interaction with helper methods.
  */
-export interface MentionableSelectInteraction extends Omit<APIMessageComponentInteraction, "data">, BaseComponentInteractionHelpers {
+export interface MentionableSelectInteraction extends Omit<APIMessageComponentInteraction, "data"> {
     data: APIMessageMentionableSelectInteractionData;
     values: string[];
     getMentionables: () => ResolvedMentionableOption[];
+    getResponse: () => APIInteractionResponse | null;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
+    deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
+    deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
+    showModal: (data: APIModalInteractionResponseCallbackData | {
+        toJSON(): APIModalInteractionResponseCallbackData;
+    }) => APIModalInteractionResponse;
 }
 export declare const MentionableSelectInteraction: {};
 /**
@@ -90,13 +132,18 @@ export declare const MentionableSelectInteraction: {};
  */
 export type MessageComponentInteraction = APIMessageComponentInteraction & {
     getResponse: () => APIInteractionResponse | null;
-    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
-    update: (data?: InteractionMessageData) => APIInteractionResponseUpdateMessage;
+    update: (data?: InteractionMessageData) => Promise<APIInteractionResponseUpdateMessage>;
     deferUpdate: () => APIInteractionResponseDeferredMessageUpdate;
     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, messageId?: string) => Promise<void>;
     /**
      * The selected values from a select menu interaction.
      * This property is only present for select menu interactions.
@@ -134,9 +181,7 @@ export declare const MessageComponentInteraction: {};
  * Wraps a raw component 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 createMessageComponentInteraction(interaction: APIMessageComponentInteraction, helpers?: {
-    onAck?: (response: APIInteractionResponse) => void;
-}): MessageComponentInteraction;
-export {};
+export declare function createMessageComponentInteraction(interaction: APIMessageComponentInteraction, helpers?: BaseComponentInteractionHelpers): MessageComponentInteraction;

package/dist/utils/MessageComponentInteraction.js

@@ -13,15 +13,17 @@ export const MessageComponentInteraction = {};
  * Wraps a raw component 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 createMessageComponentInteraction(interaction, helpers) {
     let capturedResponse = null;
+    let isDeferred = false;
     const captureResponse = (response) => {
         capturedResponse = response;
         return response;
     };
-    const reply = (data) => {
+    const reply = async (data) => {
         const normalisedData = normaliseInteractionMessageData(data);
         if (!normalisedData) {
             throw new Error("[MiniInteraction] Component replies require response data to be provided.");
@@ -30,7 +32,12 @@ export function createMessageComponentInteraction(interaction, helpers) {
             type: InteractionResponseType.ChannelMessageWithSource,
             data: normalisedData,
         });
-        helpers?.onAck?.(response);
+        if (isDeferred && helpers?.sendFollowUp) {
+            await helpers.sendFollowUp(interaction.token, response, '');
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
         return response;
     };
     const deferReply = (options) => {
@@ -44,24 +51,36 @@ export function createMessageComponentInteraction(interaction, helpers) {
                 type: InteractionResponseType.DeferredChannelMessageWithSource,
             };
         captureResponse(response);
+        isDeferred = true;
         helpers?.onAck?.(response);
         return response;
     };
-    const update = (data) => {
+    const update = async (data) => {
         const normalisedData = normaliseInteractionMessageData(data);
-        const response = normalisedData
+        const response = captureResponse(normalisedData
             ? {
                 type: InteractionResponseType.UpdateMessage,
                 data: normalisedData,
             }
             : {
                 type: InteractionResponseType.UpdateMessage,
-            };
-        return captureResponse(response);
+            });
+        if (isDeferred && helpers?.sendFollowUp) {
+            await helpers.sendFollowUp(interaction.token, response, '@original');
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
+        return response;
+    };
+    const deferUpdate = () => {
+        const response = captureResponse({
+            type: InteractionResponseType.DeferredMessageUpdate,
+        });
+        isDeferred = true;
+        helpers?.onAck?.(response);
+        return response;
     };
-    const deferUpdate = () => captureResponse({
-        type: InteractionResponseType.DeferredMessageUpdate,
-    });
     const showModal = (data) => {
         const resolvedData = typeof data === "object" &&
             "toJSON" in data &&
@@ -183,5 +202,6 @@ export function createMessageComponentInteraction(interaction, helpers) {
         getUsers,
         getMentionables,
         onAck: helpers?.onAck,
+        sendFollowUp: helpers?.sendFollowUp,
     });
 }

package/dist/utils/ModalSubmitInteraction.d.ts

@@ -5,34 +5,27 @@ import { DeferReplyOptions, InteractionMessageData } from "./interactionMessageH
  */
 export type ModalSubmitInteraction = APIModalSubmitInteraction & {
     getResponse: () => APIInteractionResponse | null;
-    reply: (data: InteractionMessageData) => APIInteractionResponseChannelMessageWithSource;
+    reply: (data: InteractionMessageData) => Promise<APIInteractionResponseChannelMessageWithSource>;
     deferReply: (options?: DeferReplyOptions) => APIInteractionResponseDeferredChannelMessageWithSource;
-    onAck?: (response: APIInteractionResponse) => void;
-    /**
-     * 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
-     */
-    getTextInputValue: (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
+     * Helper method to get the value of a text input component by its custom ID.
      */
-    getTextInputValues: () => Map<string, string>;
+    getTextFieldValue: (customId: string) => string | undefined;
     /**
-     * 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
+     * Finalise the interaction response via a webhook follow-up.
+     * This is automatically called by reply() if the interaction is deferred.
      */
-    getSelectMenuValues: (customId: string) => string[] | undefined;
+    sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<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, helpers?: {
     onAck?: (response: APIInteractionResponse) => void;
+    sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
 }): ModalSubmitInteraction;

package/dist/utils/ModalSubmitInteraction.js

@@ -1,28 +1,35 @@
-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, helpers) {
     let capturedResponse = null;
+    let isDeferred = false;
     const captureResponse = (response) => {
         capturedResponse = response;
         return response;
     };
-    const reply = (data) => {
+    const reply = async (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.");
         }
         const response = captureResponse({
             type: InteractionResponseType.ChannelMessageWithSource,
             data: normalisedData,
         });
-        helpers?.onAck?.(response);
+        if (isDeferred && helpers?.sendFollowUp) {
+            await helpers.sendFollowUp(interaction.token, response, '');
+        }
+        else {
+            helpers?.onAck?.(response);
+        }
         return response;
     };
     const deferReply = (options) => {
@@ -36,69 +43,29 @@ export function createModalSubmitInteraction(interaction, helpers) {
                 type: InteractionResponseType.DeferredChannelMessageWithSource,
             };
         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);
-                    }
-                }
-            }
-            // 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);
+    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 (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),
-        onAck: helpers?.onAck,
+        getTextFieldValue,
+        sendFollowUp: helpers?.sendFollowUp,
     });
 }

package/dist/utils/interactionMessageHelpers.js

@@ -52,6 +52,13 @@ export function normaliseInteractionMessageData(data) {
     if (data.flags !== undefined) {
         responseData.flags = normaliseMessageFlags(data.flags);
     }
+    // Automatically handle IsComponentsV2 flag if Components V2 are detected
+    if (responseData.components && Array.isArray(responseData.components)) {
+        if (containsComponentsV2(responseData.components)) {
+            const currentFlags = responseData.flags ?? 0;
+            responseData.flags = (currentFlags | (0x1 << 12)); // 0x1 << 12 is IsComponentsV2
+        }
+    }
     return responseData;
 }
 function containsComponentsV2(components) {

package/package.json

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