@minesa-org/mini-interaction 0.2.8 → 0.2.10

package/dist/clients/MiniInteraction.js

@@ -1278,6 +1278,8 @@ export class MiniInteraction {
                     const interactionWithHelpers = createUserContextMenuInteraction(commandInteraction, {
                         onAck: (response) => ackResolver?.(response),
                         sendFollowUp,
+                        canRespond: (id) => this.canRespond(id),
+                        trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
@@ -1288,6 +1290,8 @@ export class MiniInteraction {
                     const interactionWithHelpers = createAppCommandInteraction(commandInteraction, {
                         onAck: (response) => ackResolver?.(response),
                         sendFollowUp,
+                        canRespond: (id) => this.canRespond(id),
+                        trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =
@@ -1299,6 +1303,8 @@ export class MiniInteraction {
                     const interactionWithHelpers = createMessageContextMenuInteraction(commandInteraction, {
                         onAck: (response) => ackResolver?.(response),
                         sendFollowUp,
+                        canRespond: (id) => this.canRespond(id),
+                        trackResponse: (id, token, state) => this.trackInteractionState(id, token, state),
                     });
                     response = await command.handler(interactionWithHelpers);
                     resolvedResponse =

package/dist/utils/CommandInteractionOptions.d.ts

@@ -146,7 +146,7 @@ export interface CommandInteraction extends Omit<APIChatInputApplicationCommandI
     reply(data: InteractionMessageData): APIInteractionResponseChannelMessageWithSource;
     followUp(data: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource>;
     edit(data?: InteractionMessageData): APIInteractionResponseUpdateMessage;
-    editReply(data?: InteractionMessageData): Promise<APIInteractionResponseUpdateMessage>;
+    editReply(data?: InteractionMessageData): Promise<APIInteractionResponseChannelMessageWithSource | APIInteractionResponseUpdateMessage>;
     deferReply(options?: DeferReplyOptions): APIInteractionResponseDeferredChannelMessageWithSource;
     showModal(data: APIModalInteractionResponseCallbackData | {
         toJSON(): APIModalInteractionResponseCallbackData;

package/dist/utils/CommandInteractionOptions.js

@@ -1,4 +1,4 @@
-import { ApplicationCommandOptionType, InteractionResponseType, } from "discord-api-types/v10";
+import { ApplicationCommandOptionType, InteractionResponseType, InteractionType, } from "discord-api-types/v10";
 import { normaliseInteractionMessageData, normaliseMessageFlags, } from "./interactionMessageHelpers.js";
 export const ResolvedUserOption = {};
 export const MentionableOption = {};
@@ -405,10 +405,24 @@ export function createCommandInteraction(interaction, helpers) {
             if (!this.canRespond?.(this.id)) {
                 throw new Error('Interaction cannot edit reply: expired');
             }
-            const response = createMessageResponse(InteractionResponseType.UpdateMessage, data);
+            // Slash commands (type 2) MUST use ChannelMessageWithSource (type 4) for their initial response,
+            // or UpdateMessage (type 7) if they are updating a component interaction message.
+            // However, for as-yet-unresponded slash commands, we need type 4.
+            const interactionAny = interaction;
+            const isComponent = interactionAny.type === InteractionType.MessageComponent;
+            let response;
+            if (isComponent) {
+                response = createMessageResponse(InteractionResponseType.UpdateMessage, data);
+            }
+            else {
+                response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, 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');
+                // If we already sent an ACK (like a DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE), 
+                // we return the original captured response to avoid sending type 4/7 back to the initial POST.
+                return capturedResponse;
             }
             // Track response
             this.trackResponse?.(this.id, this.token, 'responded');

package/dist/utils/ContextMenuInteraction.d.ts

@@ -14,6 +14,8 @@ export type ContextMenuInteractionHelpers = {
     }) => APIModalInteractionResponse;
     onAck?: (response: APIInteractionResponse) => void;
     sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
 };
 /**
  * User context menu interaction with helper methods.
@@ -46,6 +48,8 @@ export declare const AppCommandInteraction: {};
 export declare function createUserContextMenuInteraction(interaction: APIUserApplicationCommandInteraction, helpers?: {
     onAck?: (response: APIInteractionResponse) => void;
     sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
 }): UserContextMenuInteraction;
 /**
  * Wraps a raw message context menu interaction with helper methods.
@@ -57,6 +61,8 @@ export declare function createUserContextMenuInteraction(interaction: APIUserApp
 export declare function createMessageContextMenuInteraction(interaction: APIMessageApplicationCommandInteraction, helpers?: {
     onAck?: (response: APIInteractionResponse) => void;
     sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
 }): MessageContextMenuInteraction;
 /**
  * Wraps a raw primary entry point interaction with helper methods.
@@ -68,4 +74,6 @@ export declare function createMessageContextMenuInteraction(interaction: APIMess
 export declare function createAppCommandInteraction(interaction: APIPrimaryEntryPointCommandInteraction, helpers?: {
     onAck?: (response: APIInteractionResponse) => void;
     sendFollowUp?: (token: string, response: APIInteractionResponse, messageId?: string) => Promise<void>;
+    canRespond?: (interactionId: string) => boolean;
+    trackResponse?: (interactionId: string, token: string, state: 'responded' | 'deferred') => void;
 }): AppCommandInteraction;

package/dist/utils/ContextMenuInteraction.js

@@ -28,8 +28,12 @@ function createContextMenuInteractionHelpers(interaction, helpers) {
         return captureResponse({ type });
     }
     const reply = (data) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot respond: already responded or expired");
+        }
         const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
         hasResponded = true;
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'responded');
         helpers?.onAck?.(response);
         return response;
     };
@@ -41,20 +45,31 @@ function createContextMenuInteractionHelpers(interaction, helpers) {
         return response;
     };
     const editReply = async (data) => {
-        const response = createMessageResponse(InteractionResponseType.UpdateMessage, data);
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot edit reply: expired");
+        }
+        // Context menu commands (User/Message) MUST use ChannelMessageWithSource (4)
+        // for their initial response if it's the first response.
+        const response = createMessageResponse(InteractionResponseType.ChannelMessageWithSource, data);
         if (helpers?.sendFollowUp && (isDeferred || hasResponded)) {
             await helpers.sendFollowUp(interaction.token, response, '@original');
+            return capturedResponse;
         }
         hasResponded = true;
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'responded');
         return response;
     };
     const deferReply = (options = {}) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot defer: already responded or expired");
+        }
         const flags = normaliseMessageFlags(options.flags);
         const response = captureResponse({
             type: InteractionResponseType.DeferredChannelMessageWithSource,
             data: flags ? { flags } : undefined,
         });
         isDeferred = true;
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'deferred');
         helpers?.onAck?.(response);
         return response;
     };
@@ -70,10 +85,13 @@ function createContextMenuInteractionHelpers(interaction, helpers) {
         getResponse,
         reply,
         followUp,
-        editReply,
+        editReply: editReply,
         deferReply,
         showModal,
+        onAck: helpers?.onAck,
         sendFollowUp: helpers?.sendFollowUp,
+        canRespond: helpers?.canRespond,
+        trackResponse: helpers?.trackResponse,
     };
 }
 /**

package/dist/utils/MessageComponentInteraction.js

@@ -24,6 +24,9 @@ export function createMessageComponentInteraction(interaction, helpers) {
         return response;
     };
     const reply = async (data) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot respond: already responded or expired");
+        }
         const normalisedData = normaliseInteractionMessageData(data);
         if (!normalisedData) {
             throw new Error("[MiniInteraction] Component replies require response data to be provided.");
@@ -38,9 +41,13 @@ export function createMessageComponentInteraction(interaction, helpers) {
         else {
             helpers?.onAck?.(response);
         }
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'responded');
         return response;
     };
     const deferReply = (options) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot defer: already responded or expired");
+        }
         const flags = normaliseMessageFlags(options?.flags);
         const response = flags !== undefined
             ? {
@@ -52,10 +59,14 @@ export function createMessageComponentInteraction(interaction, helpers) {
             };
         captureResponse(response);
         isDeferred = true;
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'deferred');
         helpers?.onAck?.(response);
         return response;
     };
     const update = async (data) => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot update: already responded or expired");
+        }
         const normalisedData = normaliseInteractionMessageData(data);
         const response = captureResponse(normalisedData
             ? {
@@ -71,13 +82,18 @@ export function createMessageComponentInteraction(interaction, helpers) {
         else {
             helpers?.onAck?.(response);
         }
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'responded');
         return response;
     };
     const deferUpdate = () => {
+        if (helpers?.canRespond && !helpers.canRespond(interaction.id)) {
+            throw new Error("[MiniInteraction] Interaction cannot defer update: already responded or expired");
+        }
         const response = captureResponse({
             type: InteractionResponseType.DeferredMessageUpdate,
         });
         isDeferred = true;
+        helpers?.trackResponse?.(interaction.id, interaction.token, 'deferred');
         helpers?.onAck?.(response);
         return response;
     };

package/package.json

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