@minesa-org/mini-interaction 0.4.7 → 0.4.9

package/dist/compat/MiniInteraction.d.ts

@@ -80,6 +80,8 @@ export declare class MiniInteraction {
     private normalizeModuleExports;
     private normalizeExportValue;
     private walkFiles;
+    private getDefaultInitialResponse;
+    private isDeferredResponse;
     private isImportableModule;
     private isInteractionCommand;
     private getCommandName;

package/dist/compat/MiniInteraction.js

@@ -31,6 +31,14 @@ export class MiniInteraction {
     }
     createNodeHandler() {
         return async (req, res) => {
+            let responseSent = false;
+            const commitInitialResponse = (response) => {
+                if (responseSent)
+                    return false;
+                this.sendJson(res, 200, response);
+                responseSent = true;
+                return true;
+            };
             try {
                 const body = await this.readRawBody(req);
                 const signature = this.getHeader(req.headers, "x-signature-ed25519");
@@ -58,17 +66,20 @@ export class MiniInteraction {
                     this.sendJson(res, 200, { type: InteractionResponseType.Pong });
                     return;
                 }
-                const response = await this.dispatch(interaction);
-                this.sendJson(res, 200, response ?? {
-                    type: InteractionResponseType.DeferredChannelMessageWithSource,
-                });
+                const response = await this.dispatch(interaction, commitInitialResponse);
+                if (!responseSent) {
+                    this.sendJson(res, 200, response ?? this.getDefaultInitialResponse(interaction));
+                    responseSent = true;
+                }
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : "[MiniInteraction] Unknown error";
                 if (this.options.debug) {
                     console.error("[MiniInteraction] createNodeHandler failed", error);
                 }
-                this.sendJson(res, 500, { error: message });
+                if (!responseSent) {
+                    this.sendJson(res, 500, { error: message });
+                }
             }
         };
     }
@@ -156,29 +167,29 @@ export class MiniInteraction {
             }
         };
     }
-    async dispatch(interaction) {
+    async dispatch(interaction, commitInitialResponse) {
         const modules = await this.loadModules();
         if (interaction.type === InteractionType.ApplicationCommand) {
             const command = modules.commands.find((candidate) => this.getCommandName(candidate) === interaction.data.name);
             if (!command)
                 return undefined;
-            return this.executeCommandHandler(command.handler, interaction);
+            return this.executeCommandHandler(command.handler, interaction, commitInitialResponse);
         }
         if (interaction.type === InteractionType.MessageComponent) {
             const component = modules.components.find((candidate) => candidate.customId === interaction.data.custom_id);
             if (!component)
                 return undefined;
-            return this.executeComponentHandler(component.handler, interaction);
+            return this.executeComponentHandler(component.handler, interaction, commitInitialResponse);
         }
         if (interaction.type === InteractionType.ModalSubmit) {
             const modal = modules.modals.find((candidate) => candidate.customId === interaction.data.custom_id);
             if (!modal)
                 return undefined;
-            return this.executeModalHandler(modal.handler, interaction);
+            return this.executeModalHandler(modal.handler, interaction, commitInitialResponse);
         }
         return undefined;
     }
-    async executeCommandHandler(handler, interaction) {
+    async executeCommandHandler(handler, interaction, commitInitialResponse) {
         return this.runWithResponseLifecycle(interaction, async (helpers) => {
             switch (interaction.data.type) {
                 case ApplicationCommandType.ChatInput:
@@ -193,17 +204,19 @@ export class MiniInteraction {
                     }
                     throw new Error(`[MiniInteraction] Unsupported application command type: ${String(interaction.data.type)}`);
             }
-        });
+        }, commitInitialResponse);
     }
-    async executeComponentHandler(handler, interaction) {
-        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)));
+    async executeComponentHandler(handler, interaction, commitInitialResponse) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createMessageComponentInteraction(interaction, helpers)), commitInitialResponse);
     }
-    async executeModalHandler(handler, interaction) {
-        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)));
+    async executeModalHandler(handler, interaction, commitInitialResponse) {
+        return this.runWithResponseLifecycle(interaction, async (helpers) => handler(createModalSubmitInteraction(interaction, helpers)), commitInitialResponse);
     }
-    async runWithResponseLifecycle(interaction, executor) {
+    async runWithResponseLifecycle(interaction, executor, commitInitialResponse) {
         let ackResponse;
         let initialResponseCommitted = false;
+        let followUpSent = false;
+        let committedInitialResponse;
         const helpers = {
             // Legacy helper contracts use canRespond for both initial acknowledgements
             // and later editReply/followUp calls. The compat layer does not currently
@@ -215,6 +228,10 @@ export class MiniInteraction {
             },
             onAck: (response) => {
                 ackResponse = response;
+                if (!initialResponseCommitted && commitInitialResponse?.(response)) {
+                    initialResponseCommitted = true;
+                    committedInitialResponse = response;
+                }
             },
             sendFollowUp: async (token, response, messageId) => {
                 // If the initial interaction response has not been sent yet, collapse the
@@ -228,9 +245,11 @@ export class MiniInteraction {
                 const responseData = "data" in response ? response.data ?? {} : {};
                 if (messageId === "@original") {
                     await this.rest.editOriginal(token, responseData);
+                    followUpSent = true;
                     return;
                 }
                 await this.rest.createFollowup(token, responseData);
+                followUpSent = true;
             },
         };
         const autoDeferMs = Math.min(2500, this.options.timeoutConfig?.initialResponseTimeout ?? 2500);
@@ -241,10 +260,13 @@ export class MiniInteraction {
                 if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
                     console.warn(`[MiniInteraction] Auto-deferred interaction ${interaction.id} after ${autoDeferMs}ms.`);
                 }
-                ackResponse = {
-                    type: InteractionResponseType.DeferredChannelMessageWithSource,
-                };
+                const deferredResponse = this.getDefaultInitialResponse(interaction);
+                ackResponse = deferredResponse;
                 helpers.trackResponse(interaction.id, interaction.token, "deferred");
+                if (!initialResponseCommitted && commitInitialResponse?.(deferredResponse)) {
+                    initialResponseCommitted = true;
+                    committedInitialResponse = deferredResponse;
+                }
             }, autoDeferMs)
             : undefined;
         const timeoutWarningMs = this.options.timeoutConfig?.initialResponseTimeout;
@@ -260,6 +282,18 @@ export class MiniInteraction {
             if (this.options.debug || this.options.timeoutConfig?.enableResponseDebugLogging) {
                 console.debug(`[MiniInteraction] Interaction ${interaction.id} completed with ${result ? "explicit" : "fallback"} response.`);
             }
+            if (initialResponseCommitted &&
+                result &&
+                !followUpSent &&
+                committedInitialResponse &&
+                this.isDeferredResponse(committedInitialResponse) &&
+                !this.isDeferredResponse(result)) {
+                const responseData = "data" in result ? result.data ?? {} : {};
+                await this.rest.editOriginal(interaction.token, responseData);
+            }
+            if (initialResponseCommitted) {
+                return undefined;
+            }
             initialResponseCommitted = true;
             return result ?? ackResponse;
         }
@@ -351,6 +385,16 @@ export class MiniInteraction {
         }));
         return results.flat();
     }
+    getDefaultInitialResponse(interaction) {
+        if (interaction.type === InteractionType.MessageComponent) {
+            return { type: InteractionResponseType.DeferredMessageUpdate };
+        }
+        return { type: InteractionResponseType.DeferredChannelMessageWithSource };
+    }
+    isDeferredResponse(response) {
+        return (response.type === InteractionResponseType.DeferredChannelMessageWithSource ||
+            response.type === InteractionResponseType.DeferredMessageUpdate);
+    }
     isImportableModule(filePath) {
         if (filePath.endsWith(".d.ts"))
             return false;

package/dist/core/http/DiscordRestClient.d.ts

@@ -12,7 +12,9 @@ export declare class DiscordRestClient {
     private readonly baseUrl;
     private readonly maxRetries;
     constructor(options: DiscordRestClientOptions);
-    request<T>(path: string, init?: RequestInit): Promise<T>;
+    request<T>(path: string, init?: RequestInit & {
+        authenticated?: boolean;
+    }): Promise<T>;
     createFollowup(interactionToken: string, body: unknown): Promise<unknown>;
     editOriginal(interactionToken: string, body: unknown): Promise<unknown>;
 }

package/dist/core/http/DiscordRestClient.js

@@ -12,13 +12,14 @@ export class DiscordRestClient {
     }
     async request(path, init = {}) {
         let lastError;
+        const { authenticated = true, ...requestInit } = init;
         for (let attempt = 0; attempt <= this.maxRetries; attempt += 1) {
             const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-                ...init,
+                ...requestInit,
                 headers: {
-                    Authorization: `Bot ${this.options.token}`,
+                    ...(authenticated ? { Authorization: `Bot ${this.options.token}` } : {}),
                     'Content-Type': 'application/json',
-                    ...(init.headers ?? {}),
+                    ...(requestInit.headers ?? {}),
                 },
             });
             if (response.status === 429) {
@@ -35,7 +36,7 @@ export class DiscordRestClient {
                 await sleep(150 * (attempt + 1));
                 continue;
             }
-            lastError = new Error(`[DiscordRestClient] ${init.method ?? 'GET'} ${path} failed: ${response.status}`);
+            lastError = new Error(`[DiscordRestClient] ${requestInit.method ?? 'GET'} ${path} failed: ${response.status}`);
             break;
         }
         throw lastError instanceof Error ? lastError : new Error('[DiscordRestClient] unknown request failure');
@@ -44,12 +45,14 @@ export class DiscordRestClient {
         return this.request(`/webhooks/${this.options.applicationId}/${interactionToken}`, {
             method: 'POST',
             body: JSON.stringify(body),
+            authenticated: false,
         });
     }
     editOriginal(interactionToken, body) {
         return this.request(`/webhooks/${this.options.applicationId}/${interactionToken}/messages/@original`, {
             method: 'PATCH',
             body: JSON.stringify(body),
+            authenticated: false,
         });
     }
 }

package/package.json

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