所有交互的未知交互 - Discord.js v13

Question

All of a sudden I keep on getting this error on most interactions and my bot just sends `"Bot is thinking...".

[UnhandledRejection] DiscordAPIError: Unknown interaction
    at RequestHandler.execute (/Users/main/Desktop/Discordbots/gamerscavern/node_modules/discord.js/src/rest/RequestHandler.js:349:13)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at async RequestHandler.push (/Users/main/Desktop/Discordbots/gamerscavern/node_modules/discord.js/src/rest/RequestHandler.js:50:14)
    at async SelectMenuInteraction.reply (/Users/main/Desktop/Discordbots/gamerscavern/node_modules/discord.js/src/structures/interfaces/InteractionResponses.js:98:5)

Example this help command. Which returns Unknown interaction on the interaction.update() part in the collector AND in the filter when another user interacts with it. I have no clue why this is happening. And as mentioned, it worked fine just a few hours ago.

Here is my code:

Help command:

const {
    Client,
    Message,
    MessageEmbed,
    MessageActionRow,
    MessageSelectMenu,
} = require('discord.js');

module.exports = {
    name: 'help',
    description: 'List all of my commands or info about a specific command.',
    aliases: ['commands'],
    usage: '[command name]',
    category: 'info',
    cooldown: 3,
    /**
     *
     * @param {Client} client
     * @param {Message} message
     * @param {String[]} args
     */
    execute: async (client, message, args, prefix) => {
        if (message.author.bot) return;
        const data = [];
        const { commands } = message.client;

        const emojis = {
            config: '⚙️',
            info: 'ℹ️',
            moderation: '🔨',
            owner: '🔐',
            utility: '🛠',
            voice: '🗣',
            welcoming: '👋',
        };

        if (!args[0]) {
            const directories = [
                ...new Set(client.commands.map((cmd) => cmd.category)),
            ].filter((e) => e !== 'secrets' && e !== undefined);

            const formatString = (str) =>
                `${str[0].toUpperCase()}${str.slice(1).toLowerCase()}`;

            const categories = directories.map((dir) => {
                const getCommands = client.commands
                    .filter((cmd) => cmd.category === dir)
                    .map((cmd) => {
                        return {
                            name: cmd.name || 'There is no name',
                            description:
                                cmd.description ||
                                'There is no description for this command',
                        };
                    });

                return {
                    directory: formatString(dir),
                    commands: getCommands,
                };
            });

            const initialEmbed = new MessageEmbed()
                .setTitle('Developer: Kev#1880')
                .setDescription(
                    '~~———————————————~~\n** Links ➼ ** [Invite](https://discord.com/api/oauth2/authorize?client_id=711371556504207423&permissions=8&scope=bot) | [Server](https://discord.gg/XkCTA88) | [Upvote](https://top.gg/bot/711371556504207423/vote)    \n~~———————————————~~\n\n**Please choose a category in the dropdown menu**'
                )
                .setColor('#5787E8')
                .setThumbnail(client.user.displayAvatarURL({ format: 'png' }))
                .setFooter(
                    `Requested by: ${message.author.tag}`,
                    message.author.displayAvatarURL({ format: 'png' })
                )
                .setTimestamp();

            const components = (state) => [
                new MessageActionRow().addComponents(
                    new MessageSelectMenu()
                        .setCustomId('help-menu')
                        .setPlaceholder('Please select a category')
                        .setDisabled(state)
                        .addOptions(
                            categories.map((cmd) => {
                                return {
                                    label: cmd.directory,
                                    value: cmd.directory.toLowerCase(),
                                    description: `Commands from ${cmd.directory} category`,
                                    emoji:
                                        emojis[cmd.directory.toLowerCase()] ||
                                        null,
                                };
                            })
                        )
                ),
            ];

            const initialMessage = await message.channel.send({
                embeds: [initialEmbed],
                components: components(false),
            });

            const filter = async (interaction) => {
                if (interaction.user.id === message.author.id) {
                    return true;
                }
                interaction.reply({
                    content: `This is not your help menu, create your own with >help!`,
                    ephemeral: true,
                });
                return false;
            };

            const collector = initialMessage.createMessageComponentCollector({
                filter,
                componentType: 'SELECT_MENU',
                time: 600000,
            });

            collector.on('collect', (interaction) => {
                console.log(interaction);
                const [directory] = interaction.values;
                const category = categories.find(
                    (x) => x.directory.toLowerCase() === directory
                );

                const categoryEmbed = new MessageEmbed()
                    .setTitle(`${formatString(directory)} commands`)
                    .setDescription(
                        '~~———————————————~~\n** Links ➼ ** [Invite](https://discord.com/api/oauth2/authorize?client_id=711371556504207423&permissions=8&scope=bot) | [Server](https://discord.gg/XkCTA88) | [Upvote](https://top.gg/bot/711371556504207423/vote)    \n~~———————————————~~\n\n**Here are the list of commands**'
                    )
                    .setColor('#5787E8')
                    .addFields(
                        category.commands.map((cmd) => {
                            return {
                                name: `\`${cmd.name}\``,
                                value: cmd.description,
                                inline: true,
                            };
                        })
                    )
                    .setThumbnail(
                        client.user.displayAvatarURL({ format: 'png' })
                    )
                    .setFooter(
                        `Requested by: ${message.author.tag}`,
                        message.author.displayAvatarURL({ format: 'png' })
                    )
                    .setTimestamp();

                interaction.update({
                    embeds: [categoryEmbed],
                });
            });

            collector.on('end', () => {
                const ranOut = new MessageEmbed()
                    .setColor('RED')
                    .setTitle('Oops!')
                    .setDescription(
                        'Interaction ran out of time! Please create a new help menu!'
                    )
                    .setThumbnail(
                        client.user.displayAvatarURL({ format: 'png' })
                    )
                    .setFooter(
                        `Requested by: ${message.author.tag}`,
                        message.author.displayAvatarURL({ format: 'png' })
                    )
                    .setTimestamp();

                initialMessage.edit({
                    embeds: [ranOut],
                    components: components(true),
                });
            });
        }
        if (args[0]) {
            const name = args[0].toLowerCase();
            const command =
                commands.get(name) ||
                commands.find((c) => c.aliases && c.aliases.includes(name));
            if (!command) {
                return message.reply({
                    content: "that's not a valid command!",
                });
            }

            // data.push(`**Name:** ${command.name}`);

            if (command.aliases)
                data.push(`**Aliases:** ${command.aliases.join(', ')}`);
            if (command.description)
                data.push(`**Description:** ${command.description}`);
            if (command.nb) data.push(`**NB:** ${command.nb}`);
            if (command.userPermissions)
                data.push(
                    `**User Permissions:** \`${command.userPermissions.join(
                        ', '
                    )}\``
                );
            if (command.botPermissions)
                data.push(
                    `**Bot Permissions:** ${command.botPermissions
                        .map((perm) => {
                            return `\`${perm}\``;
                        })
                        .join(', ')}`
                );
            if (command.usage)
                data.push(
                    `**Usage:** \`${prefix}${command.name} ${command.usage}\``
                );
            if (command.examples)
                data.push(`**Examples:**
            ${command.examples
                .map((example) => {
                    return `\`${prefix}${command.name} ${example}\``;
                })
                .join('\n')}
        `);

            data.push(`**Cooldown:** ${command.cooldown || 3} second(s)`);

            const commandHelp = new MessageEmbed()
                .setTitle(`Command: **${command.name}**`)
                .setColor('#5787E8')
                .setDescription(`${data.join('\n')}`)
                .setFooter(
                    `Requested by: ${message.author.tag}`,
                    message.author.displayAvatarURL({ format: 'png' })
                );

            return message.reply({ embeds: [commandHelp] });
        }
    },
};

interactionCreate event:

const blacklist = require('../../models/blacklists.js');
const guildBlacklist = require('../../models/guildBlacklist.js');
const reactionRoles = require('../../models/reactionRoles.js');
module.exports = async (Discord, client, interaction) => {
    //Slash Command Handling
    if (interaction.isCommand()) {
        // await interaction.deferReply();
        //blacklists
        const bl = await blacklist.findOne({ Client: client.user.id });
        if (bl) {
            if (bl.Users) {
                if (bl.Users.includes(interaction.user.id)) return;
            }
        }

        const gbl = await guildBlacklist.findOne({
            Guild: interaction.guild.id,
        });
        if (gbl) {
            if (gbl.Users) {
                if (gbl.Users.includes(interaction.user.id)) return;    
            }
        }

        const cmd = client.slashCommands.get(interaction.commandName);
        if (!cmd) return interaction.reply({ content: 'An error has occured' });

        const args = [];

        for (let option of interaction.options.data) {
            if (option.type === 'SUB_COMMAND') {
                if (option.name) args.push(option.name);
                option.options?.forEach((x) => {
                    if (x.value) args.push(x.value);
                });
            } else if (option.value) args.push(option.value);
        }
        interaction.member = interaction.guild.members.cache.get(
            interaction.user.id
        );

        if (!interaction.member.permissions.has(cmd.userPermissions || []))
            return interaction.reply({
                content: 'You do not have the permissions to use this command!',
                ephemeral: true,
            });

        cmd.execute(client, interaction, args);
    }

    //Context Menu Handling
    if (interaction.isContextMenu()) {
        await interaction.deferReply();
        const command = client.slashCommands.get(interaction.commandName);
        if (command) command.execute(client, interaction);
    }

    //Reaction Roles Handling
    if (interaction.isSelectMenu()) {
        await interaction.deferReply();
        const reactionPanel = await reactionRoles.findOne({
            guildId: interaction.guildId,
            'reactionPanels.customId': `${interaction.customId}`,
        });

        if (reactionPanel) {
            //if (interaction.customId !== 'reaction-roles') return;
            const roleId = interaction.values[0];

            const role = interaction.guild.roles.cache.get(roleId);
            if (!role) return;

            const memberRoles = interaction.member.roles;

            const hasRole = memberRoles.cache.has(roleId);

            if (hasRole) {
                memberRoles.remove(roleId);
                interaction.followUp({
                    content: `${role.name} has been removed from you`,
                    ephemeral: true,
                });
            } else {
                memberRoles.add(roleId);
                interaction.followUp({
                    content: `${role.name} has been added to you`,
                    ephemeral: true,
                });
            }
        }
    }
};

Answer 1

What happened

---

If you do not reply or acknowledge the interaction in 3 seconds. There's a cooldown!
The user will see interaction failed and the reply gate is closed.

Solution

---

However, if you defer the reply and edit later, the gate will open until you update the defer or edit the reply. Here's how to do it, and here's the documentation about it .

interaction.deferReply();

// Do some stuff that takes time right here...

interaction.editReply({ content: "replied" });

---

To answer your other question about the bot sending Bot is thinking... ,
It happens when you defer without editing the reply after.
It will stay like that until you do something.