hikari-arc 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

arc/command/user.py

@@ -14,7 +14,7 @@ if t.TYPE_CHECKING:
     import asyncio
 
     from arc.abc.command import CallableCommandProto
-    from arc.internal.types import UserContextCallbackT
+    from arc.internal.types import UserCommandCallbackT
 
 __all__ = ("UserCommand", "user_command")
 
@@ -66,33 +66,36 @@ class UserCommand(CallableCommandBase[ClientT, hikari.api.ContextMenuCommandBuil
 def user_command(
     name: str,
     *,
-    guilds: t.Sequence[hikari.SnowflakeishOr[hikari.PartialGuild]] | None = None,
-    is_dm_enabled: bool = True,
-    is_nsfw: bool = False,
-    autodefer: bool | AutodeferMode = True,
-    default_permissions: hikari.UndefinedOr[hikari.Permissions] = hikari.UNDEFINED,
+    guilds: t.Sequence[hikari.PartialGuild | hikari.Snowflakeish] | hikari.UndefinedType = hikari.UNDEFINED,
+    is_dm_enabled: bool | hikari.UndefinedType = hikari.UNDEFINED,
+    is_nsfw: bool | hikari.UndefinedType = hikari.UNDEFINED,
+    autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
+    default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
     name_localizations: t.Mapping[hikari.Locale, str] | None = None,
-) -> t.Callable[[UserContextCallbackT[ClientT]], UserCommand[ClientT]]:
+) -> t.Callable[[UserCommandCallbackT[ClientT]], UserCommand[ClientT]]:
     """A decorator that creates a context-menu command on a user.
 
     Parameters
     ----------
     name : str
         The name of the command.
-    guilds : t.Sequence[hikari.SnowflakeishOr[hikari.PartialGuild]] | None
-        The guilds this command is available in.
-    is_dm_enabled : bool
+    guilds : t.Sequence[hikari.PartialGuild | hikari.Snowflakeish] | hikari.UndefinedType
+        The guilds this command should be enabled in, if left as undefined, the command is global
+    is_dm_enabled : bool | hikari.UndefinedType
         Whether this command is enabled in DMs.
-    is_nsfw : bool
+    is_nsfw : bool | hikari.UndefinedType
         Whether this command is NSFW.
-    autodefer : bool | AutodeferMode
-        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond, by default True
-    default_permissions : hikari.UndefinedOr[hikari.Permissions]
+    autodefer : bool | AutodeferMode | hikari.UndefinedType
+        If True, this command will be automatically deferred if it takes longer than 2 seconds to respond
+    default_permissions : hikari.Permissions | hikari.UndefinedType
         The default permissions for this command.
         Keep in mind that guild administrators can change this, it should only be used to provide safe defaults.
     name_localizations : t.Mapping[hikari.Locale, str] | None
         The localizations for this command's name.
 
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent plugin or client.
+
     Usage
     -----
     ```py
@@ -103,13 +106,13 @@ def user_command(
     ```
     """
 
-    def decorator(callback: UserContextCallbackT[ClientT]) -> UserCommand[ClientT]:
-        guild_ids = [hikari.Snowflake(guild) for guild in guilds] if guilds else []
+    def decorator(callback: UserCommandCallbackT[ClientT]) -> UserCommand[ClientT]:
+        guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
 
         return UserCommand(
             callback=callback,
             name=name,
-            autodefer=AutodeferMode(autodefer),
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
             guilds=guild_ids,
             is_dm_enabled=is_dm_enabled,
             is_nsfw=is_nsfw,

arc/context/autocomplete.py

@@ -16,6 +16,7 @@ __all__ = ("AutocompleteData",)
 
 
 # Don't slot, because we want to use cached_property.
+@t.final
 @attr.define(slots=False, kw_only=True)
 class AutocompleteData(t.Generic[ClientT, ChoiceT]):
     """The data that is provided to an autocomplete callback."""

arc/context/base.py

@@ -10,7 +10,9 @@ from contextlib import suppress
 import attr
 import hikari
 
+from arc.abc.option import OptionType  # noqa: TCH001 Needed for tests
 from arc.errors import NoResponseIssuedError, ResponseAlreadyIssuedError
+from arc.internal.options import OPTIONTYPE_TO_TYPE, resolve_snowflake_value
 from arc.internal.types import ClientT, ResponseBuilderT
 from arc.locale import CustomLocaleRequest
 
@@ -22,7 +24,10 @@ __all__ = ("Context", "InteractionResponse", "AutodeferMode")
 logger = logging.getLogger(__name__)
 
 
+@t.final
 class AutodeferMode(enum.IntEnum):
+    """An enum representing autodefer configuration."""
+
     OFF = 0
     """Do not autodefer."""
 
@@ -42,18 +47,18 @@ class AutodeferMode(enum.IntEnum):
 class _ResponseGlue:
     """A glue object to allow for easy creation of responses in both REST and Gateway contexts."""
 
-    content: hikari.UndefinedOr[t.Any] = hikari.UNDEFINED
+    content: t.Any | hikari.UndefinedType = hikari.UNDEFINED
     flags: int | hikari.MessageFlag | hikari.UndefinedType = hikari.UNDEFINED
-    tts: hikari.UndefinedOr[bool] = hikari.UNDEFINED
-    component: hikari.UndefinedOr[hikari.api.ComponentBuilder] = hikari.UNDEFINED
-    components: hikari.UndefinedOr[t.Sequence[hikari.api.ComponentBuilder]] = hikari.UNDEFINED
-    attachment: hikari.UndefinedOr[hikari.Resourceish] = hikari.UNDEFINED
-    attachments: hikari.UndefinedOr[t.Sequence[hikari.Resourceish]] = hikari.UNDEFINED
-    embed: hikari.UndefinedOr[hikari.Embed] = hikari.UNDEFINED
-    embeds: hikari.UndefinedOr[t.Sequence[hikari.Embed]] = hikari.UNDEFINED
-    mentions_everyone: hikari.UndefinedOr[bool] = hikari.UNDEFINED
-    user_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool] = hikari.UNDEFINED
-    role_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool] = hikari.UNDEFINED
+    tts: bool | hikari.UndefinedType = hikari.UNDEFINED
+    component: hikari.api.ComponentBuilder | hikari.UndefinedType = hikari.UNDEFINED
+    components: t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType = hikari.UNDEFINED
+    attachment: hikari.Resourceish | hikari.UndefinedType = hikari.UNDEFINED
+    attachments: t.Sequence[hikari.Resourceish] | hikari.UndefinedType = hikari.UNDEFINED
+    embed: hikari.Embed | hikari.UndefinedType = hikari.UNDEFINED
+    embeds: t.Sequence[hikari.Embed] | hikari.UndefinedType = hikari.UNDEFINED
+    mentions_everyone: bool | hikari.UndefinedType = hikari.UNDEFINED
+    user_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialUser] | bool | hikari.UndefinedType = hikari.UNDEFINED
+    role_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialRole] | bool | hikari.UndefinedType = hikari.UNDEFINED
 
     def _to_dict(self) -> dict[str, t.Any]:
         return {
@@ -89,6 +94,7 @@ class _ResponseGlue:
         )
 
 
+@t.final
 class InteractionResponse:
     """Represents a message response to an interaction, allows for standardized handling of such responses.
     This class is not meant to be directly instantiated, and is instead returned by [Context][arc.context.base.Context]
@@ -145,7 +151,6 @@ class InteractionResponse:
         if self._message:
             return self._message
 
-        assert isinstance(self._context.interaction, (hikari.ComponentInteraction, hikari.ModalInteraction))
         return await self._context.interaction.fetch_initial_response()
 
     async def delete(self) -> None:
@@ -157,41 +162,45 @@ class InteractionResponse:
 
     async def edit(
         self,
-        content: hikari.UndefinedOr[t.Any] = hikari.UNDEFINED,
+        content: t.Any | hikari.UndefinedType = hikari.UNDEFINED,
         *,
-        component: hikari.UndefinedOr[hikari.api.ComponentBuilder] = hikari.UNDEFINED,
-        components: hikari.UndefinedOr[t.Sequence[hikari.api.ComponentBuilder]] = hikari.UNDEFINED,
-        attachment: hikari.UndefinedOr[hikari.Resourceish] = hikari.UNDEFINED,
-        attachments: hikari.UndefinedOr[t.Sequence[hikari.Resourceish]] = hikari.UNDEFINED,
-        embed: hikari.UndefinedOr[hikari.Embed] = hikari.UNDEFINED,
-        embeds: hikari.UndefinedOr[t.Sequence[hikari.Embed]] = hikari.UNDEFINED,
-        mentions_everyone: hikari.UndefinedOr[bool] = hikari.UNDEFINED,
-        user_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool] = hikari.UNDEFINED,
-        role_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool] = hikari.UNDEFINED,
+        component: hikari.api.ComponentBuilder | hikari.UndefinedType = hikari.UNDEFINED,
+        components: t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType = hikari.UNDEFINED,
+        attachment: hikari.Resourceish | hikari.UndefinedType = hikari.UNDEFINED,
+        attachments: t.Sequence[hikari.Resourceish] | hikari.UndefinedType = hikari.UNDEFINED,
+        embed: hikari.Embed | hikari.UndefinedType = hikari.UNDEFINED,
+        embeds: t.Sequence[hikari.Embed] | hikari.UndefinedType = hikari.UNDEFINED,
+        mentions_everyone: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        user_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialUser]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        role_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialRole]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
     ) -> InteractionResponse:
         """A short-hand method to edit the message belonging to this response.
 
         Parameters
         ----------
-        content : hikari.UndefinedOr[t.Any], optional
+        content : t.Any | hikari.UndefinedType
             The content of the message. Anything passed here will be cast to str.
-        attachment : hikari.UndefinedOr[hikari.Resourceish], optional
+        attachment : hikari.Resourceish | hikari.UndefinedType
             An attachment to add to this message.
-        attachments : hikari.UndefinedOr[t.Sequence[hikari.Resourceish]], optional
+        attachments : t.Sequence[hikari.Resourceish] | hikari.UndefinedType
             A sequence of attachments to add to this message.
-        component : hikari.UndefinedOr[hikari.api.ComponentBuilder], optional
+        component : hikari.api.ComponentBuilder | hikari.UndefinedType
             A component to add to this message.
-        components : hikari.UndefinedOr[t.Sequence[hikari.api.ComponentBuilder]], optional
+        components : t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType
             A sequence of components to add to this message.
-        embed : hikari.UndefinedOr[hikari.Embed], optional
+        embed : hikari.Embed | hikari.UndefinedType
             An embed to add to this message.
-        embeds : hikari.UndefinedOr[t.Sequence[hikari.Embed]], optional
+        embeds : t.Sequence[hikari.Embed] | hikari.UndefinedType
             A sequence of embeds to add to this message.
-        mentions_everyone : hikari.UndefinedOr[bool], optional
+        mentions_everyone : bool | hikari.UndefinedType
             If True, mentioning @everyone will be allowed.
-        user_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool], optional
+        user_mentions : t.Sequence[hikari.Snowflakish | hikari.PartialUser] | bool | hikari.UndefinedType
             The set of allowed user mentions in this message. Set to True to allow all.
-        role_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool], optional
+        role_mentions : t.Sequence[hikari.Snowflakish | hikari.PartialRole] | bool | hikari.UndefinedType
             The set of allowed role mentions in this message. Set to True to allow all.
 
         Returns
@@ -229,6 +238,7 @@ class InteractionResponse:
         return await self._context._create_response(message)
 
 
+@t.final
 class Context(t.Generic[ClientT]):
     """A context object that is proxying a Discord command interaction."""
 
@@ -244,6 +254,7 @@ class Context(t.Generic[ClientT]):
         "_created_at",
         "_autodefer_task",
         "_has_command_failed",
+        "_options",
     )
 
     def __init__(
@@ -252,6 +263,7 @@ class Context(t.Generic[ClientT]):
         self._client = client
         self._command = command
         self._interaction: hikari.CommandInteraction = interaction
+        self._options: t.Sequence[hikari.CommandInteractionOption] | None = None
         self._responses: t.MutableSequence[InteractionResponse] = []
         self._resp_builder: asyncio.Future[ResponseBuilderT] = asyncio.Future()
         self._issued_response: bool = False
@@ -264,11 +276,11 @@ class Context(t.Generic[ClientT]):
     def interaction(self) -> hikari.CommandInteraction:
         """The underlying interaction object.
 
-        .. warning::
+        !!! warning
             This should not be used directly in most cases, and is only exposed for advanced use cases.
 
-            If you use the interaction to create a response in a view,
-            you should disable the autodefer feature in your View.
+            If you use the interaction to create a response,
+            you should disable the autodefer feature in your command.
         """
         return self._interaction
 
@@ -396,6 +408,82 @@ class Context(t.Generic[ClientT]):
         """Gets the channel this context represents, None if in a DM. Requires application cache."""
         return self._interaction.get_channel()
 
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ATTACHMENT]) -> hikari.Attachment | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.MENTIONABLE]) -> hikari.User | hikari.Role | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.USER]) -> hikari.User | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ROLE]) -> hikari.Role | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.CHANNEL]) -> hikari.PartialChannel | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.STRING]) -> str | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.BOOLEAN]) -> bool | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.FLOAT]) -> float | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.INTEGER]) -> int | None:
+        ...
+
+    def get_option(self, name: str, opt_type: OptionType) -> t.Any | None:
+        """Get the value of an option by name.
+
+        Parameters
+        ----------
+        name : str
+            The name of the option.
+        opt_type : hikari.OptionType
+            The type of the option.
+
+        Returns
+        -------
+        ValueT | None
+            The value of the option, or None if it does not exist, or is not of the correct type.
+
+        Usage
+        -----
+        ```py
+        value = ctx.get_option("name", arc.OptionType.STRING)
+        if value is None:
+            # Option does not exist or is not a string
+
+        # Do something with the value
+        print(value)
+        ```
+
+        """
+        if self._options is None:
+            return None
+
+        value = next((x.value for x in self._options if x.name == name), None)
+
+        if value is hikari.Snowflake and self._interaction.resolved is not None:
+            value = resolve_snowflake_value(value, opt_type, self._interaction.resolved)
+
+        if not isinstance(value, OPTIONTYPE_TO_TYPE[opt_type]):
+            return None
+
+        return value
+
     def loc(self, key: str, use_guild: bool = True, force_locale: hikari.Locale | None = None, **kwargs: t.Any) -> str:
         """Get a localized string using the interaction's locale.
 
@@ -403,9 +491,9 @@ class Context(t.Generic[ClientT]):
         ----------
         key : str
             The key of the string to localize.
-        use_guild : bool, optional
+        use_guild : bool
             Whether to use the guild or not, if in a guild.
-        force_locale : hikari.Locale | None, optional
+        force_locale : hikari.Locale | None
             Force a locale to use, instead of the context's locale.
         kwargs : t.Any
             The keyword arguments to pass to the string formatter.
@@ -457,51 +545,55 @@ class Context(t.Generic[ClientT]):
 
     async def respond(
         self,
-        content: hikari.UndefinedOr[t.Any] = hikari.UNDEFINED,
+        content: t.Any | hikari.UndefinedType = hikari.UNDEFINED,
         *,
         flags: int | hikari.MessageFlag | hikari.UndefinedType = hikari.UNDEFINED,
-        tts: hikari.UndefinedOr[bool] = hikari.UNDEFINED,
-        component: hikari.UndefinedOr[hikari.api.ComponentBuilder] = hikari.UNDEFINED,
-        components: hikari.UndefinedOr[t.Sequence[hikari.api.ComponentBuilder]] = hikari.UNDEFINED,
-        attachment: hikari.UndefinedOr[hikari.Resourceish] = hikari.UNDEFINED,
-        attachments: hikari.UndefinedOr[t.Sequence[hikari.Resourceish]] = hikari.UNDEFINED,
-        embed: hikari.UndefinedOr[hikari.Embed] = hikari.UNDEFINED,
-        embeds: hikari.UndefinedOr[t.Sequence[hikari.Embed]] = hikari.UNDEFINED,
-        mentions_everyone: hikari.UndefinedOr[bool] = hikari.UNDEFINED,
-        user_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool] = hikari.UNDEFINED,
-        role_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool] = hikari.UNDEFINED,
-        delete_after: hikari.UndefinedOr[float | int | datetime.timedelta] = hikari.UNDEFINED,
+        tts: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        attachment: hikari.Resourceish | hikari.UndefinedType = hikari.UNDEFINED,
+        attachments: t.Sequence[hikari.Resourceish] | hikari.UndefinedType = hikari.UNDEFINED,
+        component: hikari.api.ComponentBuilder | hikari.UndefinedType = hikari.UNDEFINED,
+        components: t.Sequence[hikari.api.ComponentBuilder] | hikari.UndefinedType = hikari.UNDEFINED,
+        embed: hikari.Embed | hikari.UndefinedType = hikari.UNDEFINED,
+        embeds: t.Sequence[hikari.Embed] | hikari.UndefinedType = hikari.UNDEFINED,
+        mentions_everyone: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        user_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialUser]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        role_mentions: t.Sequence[hikari.Snowflake | hikari.PartialRole]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        delete_after: float | int | datetime.timedelta | hikari.UndefinedType = hikari.UNDEFINED,
     ) -> InteractionResponse:
         """Short-hand method to create a new message response via the interaction this context represents.
         This function automatically determines if the response should be an initial response or a followup.
 
         Parameters
         ----------
-        content : hikari.UndefinedOr[Any], optional
+        content : Any | hikari.UndefinedType
             The content of the message. Anything passed here will be cast to str.
-        tts : hikari.UndefinedOr[bool], optional
+        tts : bool | hikari.UndefinedType
             If the message should be tts or not.
-        attachment : hikari.UndefinedOr[hikari.Resourceish], optional
+        attachment : hikari.Resourceish | hikari.UndefinedType
             An attachment to add to this message.
-        attachments : hikari.UndefinedOr[t.Sequence[hikari.Resourceish]], optional
+        attachments : t.Sequence[hikari.Resourceish] | hikari.UndefinedType
             A sequence of attachments to add to this message.
-        component : hikari.UndefinedOr[hikari.api.special_endpoints.ComponentBuilder], optional
+        component : hikari.api.special_endpoints.ComponentBuilder | hikari.UndefinedType
             A component to add to this message.
-        components : hikari.UndefinedOr[t.Sequence[hikari.api.special_endpoints.ComponentBuilder]], optional
+        components : t.Sequence[hikari.api.special_endpoints.ComponentBuilder] | hikari.UndefinedType
             A sequence of components to add to this message.
-        embed : hikari.UndefinedOr[hikari.Embed], optional
+        embed : hikari.Embed | hikari.UndefinedType
             An embed to add to this message.
-        embeds : hikari.UndefinedOr[Sequence[hikari.Embed]], optional
+        embeds : Sequence[hikari.Embed] | hikari.UndefinedType
             A sequence of embeds to add to this message.
-        mentions_everyone : hikari.UndefinedOr[bool], optional
+        mentions_everyone : bool | hikari.UndefinedType
             If True, mentioning @everyone will be allowed.
-        user_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool], optional
+        user_mentions : hikari.SnowflakeishSequence[hikari.PartialUser] | bool | hikari.UndefinedType
             The set of allowed user mentions in this message. Set to True to allow all.
-        role_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool], optional
+        role_mentions : hikari.SnowflakeishSequence[hikari.PartialRole] | bool | hikari.UndefinedType
             The set of allowed role mentions in this message. Set to True to allow all.
-        flags : int | hikari.MessageFlag | hikari.UndefinedType, optional
+        flags : int | hikari.MessageFlag | hikari.UndefinedType
             Message flags that should be included with this message.
-        delete_after: hikari.UndefinedOr[float | int | datetime.timedelta], optional
+        delete_after: float | int | datetime.timedelta | hikari.UndefinedType
             Delete the response after the specified delay.
 
         Returns
@@ -566,7 +658,8 @@ class Context(t.Generic[ClientT]):
         ...
 
     async def respond_with_builder(self, builder: ResponseBuilderT) -> InteractionResponse | None:
-        """Respond to the interaction with a builder.
+        """Respond to the interaction with a builder. This method will try to turn the builder into a valid
+        response or followup, depending on the builder type and interaction state.
 
         Parameters
         ----------
@@ -581,13 +674,13 @@ class Context(t.Generic[ClientT]):
         Raises
         ------
         RuntimeError
-            The interaction was already issued an initial response.
+            The interaction was already issued an initial response and the builder can only be used for initial responses.
         """
         async with self._response_lock:
-            if self._issued_response:
+            if self._issued_response and not isinstance(builder, hikari.api.InteractionMessageBuilder):
                 raise RuntimeError("This interaction was already issued an initial response.")
 
-            if self.client.is_rest:
+            if self.client.is_rest and not self._issued_response:
                 self._resp_builder.set_result(builder)
                 self._issued_response = True
                 if not isinstance(builder, hikari.api.InteractionModalBuilder):
@@ -596,25 +689,38 @@ class Context(t.Generic[ClientT]):
                 return
 
             if isinstance(builder, hikari.api.InteractionMessageBuilder):
-                await self.interaction.create_initial_response(
-                    response_type=hikari.ResponseType.MESSAGE_CREATE,
-                    content=builder.content,
-                    tts=builder.is_tts,
-                    components=builder.components,
-                    attachments=builder.attachments,
-                    embeds=builder.embeds,
-                    mentions_everyone=builder.mentions_everyone,
-                    user_mentions=builder.user_mentions,
-                    role_mentions=builder.role_mentions,
-                    flags=builder.flags,
-                )
+                if not self._issued_response:
+                    await self.interaction.create_initial_response(
+                        response_type=hikari.ResponseType.MESSAGE_CREATE,
+                        content=builder.content,
+                        tts=builder.is_tts,
+                        components=builder.components,
+                        attachments=builder.attachments,
+                        embeds=builder.embeds,
+                        mentions_everyone=builder.mentions_everyone,
+                        user_mentions=builder.user_mentions,
+                        role_mentions=builder.role_mentions,
+                        flags=builder.flags,
+                    )
+                else:
+                    await self.interaction.execute(
+                        content=builder.content,
+                        tts=builder.is_tts,
+                        components=builder.components or hikari.UNDEFINED,
+                        attachments=builder.attachments or hikari.UNDEFINED,
+                        embeds=builder.embeds or hikari.UNDEFINED,
+                        mentions_everyone=builder.mentions_everyone,
+                        user_mentions=builder.user_mentions,
+                        role_mentions=builder.role_mentions,
+                        flags=builder.flags,
+                    )
             elif isinstance(builder, hikari.api.InteractionDeferredBuilder):
                 await self.interaction.create_initial_response(
                     response_type=hikari.ResponseType.DEFERRED_MESSAGE_CREATE, flags=builder.flags
                 )
             else:
                 await self.interaction.create_modal_response(
-                    title=builder.title, custom_id=builder.custom_id, components=builder.components
+                    title=builder.title, custom_id=builder.custom_id, components=builder.components or hikari.UNDEFINED
                 )
 
             self._issued_response = True
@@ -660,43 +766,48 @@ class Context(t.Generic[ClientT]):
 
     async def edit_initial_response(
         self,
-        content: hikari.UndefinedNoneOr[t.Any] = hikari.UNDEFINED,
+        content: t.Any | None | hikari.UndefinedType = hikari.UNDEFINED,
         *,
-        component: hikari.UndefinedNoneOr[hikari.api.ComponentBuilder] = hikari.UNDEFINED,
-        components: hikari.UndefinedNoneOr[t.Sequence[hikari.api.ComponentBuilder]] = hikari.UNDEFINED,
-        attachment: hikari.UndefinedNoneOr[hikari.Resourceish] = hikari.UNDEFINED,
-        attachments: hikari.UndefinedNoneOr[t.Sequence[hikari.Resourceish]] = hikari.UNDEFINED,
-        embed: hikari.UndefinedNoneOr[hikari.Embed] = hikari.UNDEFINED,
-        embeds: hikari.UndefinedNoneOr[t.Sequence[hikari.Embed]] = hikari.UNDEFINED,
-        mentions_everyone: hikari.UndefinedOr[bool] = hikari.UNDEFINED,
-        user_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool] = hikari.UNDEFINED,
-        role_mentions: hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool] = hikari.UNDEFINED,
+        attachment: hikari.Resourceish | None | hikari.UndefinedType = hikari.UNDEFINED,
+        attachments: t.Sequence[hikari.Resourceish] | None | hikari.UndefinedType = hikari.UNDEFINED,
+        component: hikari.api.ComponentBuilder | None | hikari.UndefinedType = hikari.UNDEFINED,
+        components: t.Sequence[hikari.api.ComponentBuilder] | None | hikari.UndefinedType = hikari.UNDEFINED,
+        embed: hikari.Embed | None | hikari.UndefinedType = hikari.UNDEFINED,
+        embeds: t.Sequence[hikari.Embed] | None | hikari.UndefinedType = hikari.UNDEFINED,
+        mentions_everyone: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        user_mentions: t.Sequence[hikari.Snowflakeish | hikari.PartialUser]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        role_mentions: t.Sequence[hikari.Snowflake | hikari.PartialRole]
+        | bool
+        | hikari.UndefinedType = hikari.UNDEFINED,
     ) -> InteractionResponse:
-        """A short-hand method to edit the initial response belonging to this interaction. If you want to edit a followup,
-        you should use the [`edit()`][arc.context.base.InteractionResponse.edit] method of the returned
-        [`InteractionResponse`][arc.context.base.InteractionResponse] response object instead.
+        """A short-hand method to edit the initial response belonging to this interaction.
+
+        If you want to edit a followup, you should use the [`edit()`][arc.context.base.InteractionResponse.edit]
+        method of the returned [`InteractionResponse`][arc.context.base.InteractionResponse] response object instead.
 
         Parameters
         ----------
-        content : hikari.UndefinedOr[Any], optional
+        content : t.Any | None | hikari.UndefinedType
             The content of the message. Anything passed here will be cast to str.
-        attachment : hikari.UndefinedOr[hikari.Resourceish], optional
+        attachment : hikari.Resourceish | None | hikari.UndefinedType
             An attachment to add to this message.
-        attachments : hikari.UndefinedOr[t.Sequence[hikari.Resourceish]], optional
+        attachments : t.Sequence[hikari.Resourceish] | None | hikari.UndefinedType
             A sequence of attachments to add to this message.
-        component : hikari.UndefinedOr[hikari.api.special_endpoints.ComponentBuilder], optional
+        component : hikari.api.ComponentBuilder | None | hikari.UndefinedType
             A component to add to this message.
-        components : hikari.UndefinedOr[t.Sequence[hikari.api.special_endpoints.ComponentBuilder]], optional
+        components : t.Sequence[hikari.api.ComponentBuilder] | None | hikari.UndefinedType
             A sequence of components to add to this message.
-        embed : hikari.UndefinedOr[hikari.Embed], optional
+        embed : hikari.Embed | None | hikari.UndefinedType
             An embed to add to this message.
-        embeds : hikari.UndefinedOr[Sequence[hikari.Embed]], optional
+        embeds : t.Sequence[hikari.Embed] | None | hikari.UndefinedType
             A sequence of embeds to add to this message.
-        mentions_everyone : hikari.UndefinedOr[bool], optional
+        mentions_everyone : bool | hikari.UndefinedType
             If True, mentioning @everyone will be allowed.
-        user_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialUser] | bool], optional
+        user_mentions : t.Sequence[hikari.Snowflakeish | hikari.PartialUser] | bool | hikari.UndefinedType
             The set of allowed user mentions in this message. Set to True to allow all.
-        role_mentions : hikari.UndefinedOr[hikari.SnowflakeishSequence[hikari.PartialRole] | bool], optional
+        role_mentions : t.Sequence[hikari.Snowflakeish | hikari.PartialRole] | bool | hikari.UndefinedType
             The set of allowed role mentions in this message. Set to True to allow all.
 
         Returns
@@ -728,14 +839,14 @@ class Context(t.Generic[ClientT]):
             else:
                 raise NoResponseIssuedError("This interaction was not yet issued an initial response.")
 
-    async def defer(self, flags: hikari.UndefinedOr[int | hikari.MessageFlag] = hikari.UNDEFINED) -> None:
+    async def defer(self, flags: int | hikari.MessageFlag | hikari.UndefinedType = hikari.UNDEFINED) -> None:
         """Short-hand method to defer an interaction response. Raises ResponseAlreadyIssuedError
         if the interaction was already responded to.
 
         Parameters
         ----------
-        flags : hikari.UndefinedOr[int | hikari.MessageFlag], optional
-            Message flags that should be included with this defer request, by default None
+        flags : int | hikari.MessageFlag | hikari.UndefinedType
+            Message flags that should be included with this defer request
 
         Raises
         ------