Encountered error while handling an interaction handler run method for interaction-handler

public run(interaction: ButtonInteraction) {
    // If the group is undefined then we should not run
    if (!this.group) return;

    // We can now run the command
    return replyWithCommands(interaction, this.group.name);
}

export async function replyWithCommands(
    interaction: ChatInputCommandInteraction | MessageComponentInteraction,
    groupName: string
) {
    await autoDeferReply(interaction);

    // Check the group exists
    const group = await getGroup(interaction.client, interaction, groupName);
    if (!group) {
        return sendDeferredEphermeralResponse(interaction, {
            content: `The group \`${groupName}\` does not exist.`,
        });
    }

    // Get all the commands for the group
    const commands = await getCommandsForGroup(
        interaction.client,
        interaction,
        group.name
    );

    // Create a button for going back to the groups
    const backButton = new ButtonBuilder() //
        .setCustomId(GroupButtonIDs.BackToGroup)
        .setEmoji(":back:")
        .setStyle(ButtonStyle.Primary);

    // Add the button to a action row
    const row = new ActionRowBuilder<ButtonBuilder>();
    row.addComponents(backButton);

    // Embed builder
    const embed = new EmbedBuilder() //
        .setColor(0x2095ab)
        .setAuthor({
            name: interaction.user.username,
            iconURL: interaction.user.displayAvatarURL(),
        })
        .addFields([
            {
                name: "Information",
                value: `Click on the 🔙 button to go back to the groups.`,
            },
            {
                name: `${group.name} Commands`,
                value:
                    commands
                        .map(
                            (command) =>
                                `\`/${command.name}\` ${command.description}`
                        )
                        .join("\n") || "No commands found",
            },
        ]);

    return sendDeferredResponse(interaction, {
        embeds: [embed],
        components: [row],
    });
}

/**
 * This util will defer the reply only when it is able to.
 *
 * @param interaction
 */
export async function autoDeferReply(
    interaction: ChatInputCommandInteraction | MessageComponentInteraction
) {
    const fromMessageComponent = isMessageComponentInteraction(interaction);
    // Defer the interaction if it hasn't already been (command interaction)
    if (
        !fromMessageComponent &&
        !interaction.deferred &&
        !interaction.replied
    ) {
        await interaction.deferReply();
    }
}

export async function sendDeferredResponse(
    interaction: ChatInputCommandInteraction | MessageComponentInteraction,
    options?: BaseMessageOptions
): Promise<InteractionResponse<boolean> | Message<boolean>> {
    const { content, embeds, components } = options ?? {};
    // Response to the interaction
    const responseObj: BaseMessageOptions = {
        content: content ?? "",
        embeds,
        components,
    };
    const fromMessageComponent = isMessageComponentInteraction(interaction);
    // A button interaction cause this function to be called
    if (fromMessageComponent && !interaction.replied) {
        return interaction.update(responseObj);
    }
    // A command interaction cause this function to be called
    return interaction.editReply(responseObj);
}