Tags

Sending Messages with {responder}

{responder} tags let you construct a message that will be sent once the action is over, or you manually send it. These tags are meant to be chained together to form a complete responder.

{responder.text;Hello!}
{responder.embed title="World"}
{responder.send}

{responder.text;message}

Appends text to the output message. If there is more text, it will be appended to the existing text.

{responder.text;Hello World} will make the output message "Hello World" {responder.text;Hello}{responder.text;World} will make the output message "Hello World" {responder.text;Hello}{responder.text;} empty text will clear existing text.

{responder.dm fallback;member} createDirectMessage

Set the responder to dm a user. This tag can be hit and miss if the user has their direct-messages closed.

{responder.embed}

This tag is used to add embeds to the message. Calling it multiple times will add multiple embeds to the message, up to a maximum of 10.

Use the Embed Builder to quickly build an embed.

{responder.embedField;name;value;inline}

Add a field to the last created embed.

{responder.embed title="My Embed" description="Fortnite or something idk"}
{responder.embedField name="My Field" value="very cool" inline=true}
{responder.embedField name="Another One" value="even cooler" inline=true}

{responder.channel;channel}

Set the channel the message will be sent to. Setting a channel with a context interaction will have the responder ignore that interaction when sending a message. The context interaction must still be replied to or it will be marked as failed.

// Do some weird logging stuff to a separate channel that the user will never see
{responder.channel;MY_LOG_CHANNEL}
{responder.text;{user.mention} ran our command!}
{responder.send} // Send the log message to the log channel

// Now we reply to the slash command (context interaction). This is required,
// not replying will have Discord mark the interaction as failed. Depending on a few factors,
// if we don't reply Atlas will automatically send a "The action did not output anything" message
// to stop it being marked as failed.
{responder.text;Hi {user.mention}! This is a reply to the context interaction that is required for it not to fail}
// No need for {responder.send} as it is automatically once the script finishes executing if its configured

{responder.reset}

Reset any options already applied to the responder. This tag has no arguments.

{responder.text;Hello}
{responder.reset}
{responder.text;Something bad happened!}

This would output "Something bad happened!"

{responder.ephemeral}

Mark the message as ephemeral, so that it is only viewable by the user who created the interaction. Only works with interactions.

{responder.error;message}

This is the same as {responder.text}, with some extras;

• Embeds will be set to red
• The message will be set to ephemeral

You should use this whenever sending error messages.

{responder.send return_id ignore_interaction} createMessage

Send the message immediately. This will automatically call {responder.reset} if the message is sent successfully.

return_id can be used to get the output message ID. return_id does not work when replying to an interaction. Discord does not give us message data when we send an interaction, however because the responder will assume you mean the context interaction, leaving out the ID should do effectively the same thing.

ignore_interaction can be set to have the responder ignore the context interaction and reply with a regular message in the context channel. The interaction still needs a reply or it will be marked as failed, you should only use this to send off a separate message.

If the responder is configured when the script finishes, it will be sent automatically. This means you probably don't need {responder.send} unless you're sending multiple messages.

{responder.edit;message}

Set the responder to edit the given message. Atlas must have sent the message to edit it. Place after the new message content.

{responder.button label callback_name stateless callback_state url emoji style actionRowIndex disabled userLock}

Adds a Button component to the message.

If you want a button to only have an emoji, here is a fun hack. Copy this empty space and paste it into the button label.

‎

{responder.select callback_name stateless callback_state disabled placeholder minValues maxValues actionRowIndex type userLock;options}

Adds a Select menu component to the message with the given options.

{responder.select
  callback_name=my_callback
  placeholder="Select an option"
  options={{[
      {
          "label": "Option One",
          "value": "1"
      },
      {
          "label": "Option Two",
          "value": "2"
      }
  ]}}
}

{responder.reference;message}

Set the responder to reference the given message. Call with no params, {responder.reference}, to stop the bot replying to the context message.

{responder.sendModal;title;callback_name;stateless;components;callback_state}

Reply to an interaction with a modal that pops up on the context users screen.

{=data;{{
  "components": [
    {
      "type": 1,
      "components": [
        {
          "type": 4,
          "custom_id": "my_input",
          "style": "short",
          "label": "Your Name",
          "required": true
        }
      ]
    }
  ]
}}}

{responder.sendModal
  title="Example Modal"
  callback_name="my_modal_callback"
  components={$data.components}
}

This script will create a modal with the title "Example Modal" and a single input field labelled "Your Name". The Component Callback action "my_modal_callback" will be run when the user submits the modal. The values will be available in the callback action as {$fields}.

{responder.clearComponents}

Clears all buttons, select menus, etc from the message. This tag has no arguments.

// This would clear all existing components from a message.
// Useful in a button callback
{responder.clearComponents}
{responder.send}

// This would send an empty message, because we're creating a button then removing it.
{responder.button label="Click me" callback_name="my_callback"}
{responder.clearComponents}
{responder.send}

{responder.deferReply;ephemeral}

Normally, actions time out after 3 seconds of not having a reply. If your action is slow, it can be important to defer your reply so you have more time. This tag will tell Discord to wait a bit longer, showing a loading state to the user while they wait. This can only be used with an interaction in context.

// Defer the reply first to show a loading state
{responder.deferReply}

// Do some time-consuming operations...
{sleep;2}

// Then send your actual response
{responder.text;Here's your response after processing!}
{responder.send}