Deferred response from modal is not working properly

[squidbus]

I'm registering a global modal callback that looks like this:

await ctx.defer(false)

const dataString = await myAsyncOperation()
await ctx.send({
    embeds: [{
        title: `Data`,
        description: dataString,
    }]
})

I expect that this would create a deferred response, call my asynchronous operation, and then update the response with my data. In reality, I get the deferred message where it says it's thinking, but the message never updates, and it seems like the subsequent operations never happen.

If I change the callback to just do a non-deferred send with dummy data, that works fine, but then I can't fetch the data I need. Additionally, when I run this code in a slash-command context, it works fine.

[Snazzah]

Weird, I've tested this and it seemed to have worked fine for global modal callbacks. Here's the example I ran it on, and it deferred and updated the message fine:

creator.registerGlobalModal('wow', async (mCtx) => {
  await mCtx.defer(false);
  console.log('start');
  await new Promise((resolve, reject) => setTimeout(resolve, 3000));
  console.log('end');
  await mCtx.send({
    embeds: [
      {
        title: `Data`,
        description: mCtx.values.text
      }
    ]
  });
});

Which version are you on? Can you send a minimal example that shows this bug?

[squidbus]

This is a minimal reproducing command for me, on version 6.3.1:

import {
    CommandContext,
    ComponentType,
    SlashCommand,
    SlashCreator,
    TextInputStyle
} from 'slash-create/web'

export default class RunCommand extends SlashCommand {
    static readonly MODAL_ID = "runModal"

    constructor(creator: SlashCreator) {
        super(creator, {
            name: "run",
            description: "Test command.",
            options: []
        })

        creator.registerGlobalModal(RunCommand.MODAL_ID, async ctx => {
            const input = ctx.values.input
            await ctx.defer()

            const data = await fetch("https://example.com")
            const text = await data.text()
            await ctx.send({
                embeds: [{
                    title: "Output",
                    description: text.substring(0, 20),
                    fields: [{
                        name: "Input",
                        value: input
                    }]
                }]
            })
        })
    }

    async run(ctx: CommandContext) {
        await ctx.sendModal({
            custom_id: RunCommand.MODAL_ID,
            title: "Test Modal",
            components: [
                {
                    type: ComponentType.ACTION_ROW,
                    components: [
                        {
                            type: ComponentType.TEXT_INPUT,
                            custom_id: "input",
                            label: "Input",
                            placeholder: "Input",
                            style: TextInputStyle.PARAGRAPH,
                            min_length: 1,
                            required: true
                        }
                    ]
                }
            ]
        })
    }
}

If I move the logic from the modal callback to the run function, it works and outputs the partial HTML. If I run it as-is and submit the modal, I get the thinking message (immediately from the defer call, not after a few seconds like if it had timed out waiting for a modal response) and it never resolves to the output.

For context I'm running this as part of a Cloudflare Worker, if that helps. I don't see any errors in the worker log, just the POST request log and any logs I put before the fetch. If I log the input value from the modal context, I do see it is the correct value.

[Snazzah]

This is probably due to workers pausing execution after the initial response (the defer) has been sent. Not sure exactly how to go around that but that's why. Might need to restructure the worker implementation a bit to get this working.

Nevermind, I figured out the issue

[Snazzah]

Fixed in v6.3.2.

[squidbus]

Yep seems to be working now, thanks!