feat: Implement with_response For Interaction Callbacks

Author: Icebluewolf

discord/interactions.py

@@ -81,7 +81,7 @@
     from .poll import Poll
     from .state import ConnectionState
     from .threads import Thread
-    from .types.interactions import Interaction as InteractionPayload
+    from .types.interactions import Interaction as InteractionPayload, InteractionCallbackResponse
     from .types.interactions import InteractionData
     from .types.interactions import InteractionMetadata as InteractionMetadataPayload
     from .types.interactions import MessageInteraction as MessageInteractionPayload
@@ -129,6 +129,7 @@ class Interaction:
         The user or member that sent the interaction. Will be `None` in PING interactions.
     message: Optional[:class:`Message`]
         The message that sent this interaction.
+        This is updated to the message object of the response after responding by sending or editing a message.
     token: :class:`str`
         The token to continue the interaction. These are valid
         for 15 minutes.
@@ -185,12 +186,16 @@ class Interaction:
         "_cs_response",
         "_cs_followup",
         "_cs_channel",
+        "_response_message_loading",
+        "_response_message_ephemeral",
     )
 
     def __init__(self, *, data: InteractionPayload, state: ConnectionState):
         self._state: ConnectionState = state
         self._session: ClientSession = state.http._HTTPClient__session
         self._original_response: InteractionMessage | None = None
+        self._response_message_loading: bool = False
+        self._response_message_ephemeral: bool = False
         self._from_data(data)
 
     def _from_data(self, data: InteractionPayload):
@@ -308,6 +313,22 @@ def is_component(self) -> bool:
         """Indicates whether the interaction is a message component."""
         return self.type == InteractionType.component
 
+    def is_loading(self) -> bool:
+        """Indicates whether the response message is in a loading state.
+
+        .. versionadded:: 2.7
+        """
+        return self._response_message_loading
+
+    def is_ephemeral(self) -> bool:
+        """Indicates whether the response message is ephemeral.
+
+        This might be useful for determining if the message was forced to be ephemeral.
+
+        .. versionadded:: 2.7
+        """
+        return self._response_message_ephemeral
+
     @utils.cached_slot_property("_cs_channel")
     @utils.deprecated("Interaction.channel", "2.7", stacklevel=4)
     def cached_channel(self) -> InteractionChannel | None:
@@ -871,6 +892,19 @@ async def pong(self) -> None:
             )
             self._responded = True
 
+    async def _process_callback_response(self, callback_response: InteractionCallbackResponse):
+        if callback_response.get("resource") and callback_response["resource"].get("message"):
+            # TODO: fix later to not raise?
+            channel = self._parent.channel
+            if channel is None:
+                raise ClientException("Channel for message could not be resolved")
+            state = _InteractionMessageState(self._parent, self._parent._state)
+            message = InteractionMessage(state=state, channel=channel, data=callback_response["resource"]["message"])  # type: ignore
+            self._parent._original_response = message
+
+        self._parent._response_message_ephemeral = callback_response["interaction"].get("response_message_ephemeral", False)
+        self._parent._response_message_loading = callback_response["interaction"].get("response_message_loading", False)
+
     async def send_message(
         self,
         content: Any | None = None,
@@ -1007,7 +1041,7 @@ async def send_message(
         adapter = async_context.get()
         http = parent._state.http
         try:
-            await self._locked_response(
+            callback_response: InteractionCallbackResponse = await self._locked_response(
                 adapter.create_interaction_response(
                     parent.id,
                     parent.token,
@@ -1031,6 +1065,8 @@ async def send_message(
             view.parent = self._parent
             self._parent._state.store_view(view)
 
+        await self._process_callback_response(callback_response)
+
         self._responded = True
         if delete_after is not None:
             await self._parent.delete_original_response(delay=delete_after)
@@ -1171,7 +1207,7 @@ async def edit_message(
         adapter = async_context.get()
         http = parent._state.http
         try:
-            await self._locked_response(
+            callback_response: InteractionCallbackResponse = await self._locked_response(
                 adapter.create_interaction_response(
                     parent.id,
                     parent.token,
@@ -1192,6 +1228,8 @@ async def edit_message(
             view.message = msg
             state.store_view(view, message_id)
 
+        await self._process_callback_response(callback_response)
+
         self._responded = True
         if delete_after is not None:
             await self._parent.delete_original_response(delay=delete_after)
@@ -1319,7 +1357,7 @@ async def premium_required(self) -> Interaction:
         self._responded = True
         return self._parent
 
-    async def _locked_response(self, coro: Coroutine[Any, Any, Any]) -> None:
+    async def _locked_response(self, coro: Coroutine[Any, Any, Any]) -> Any:
         """|coro|
 
         Wraps a response and makes sure that it's locked while executing.
@@ -1338,7 +1376,7 @@ async def _locked_response(self, coro: Coroutine[Any, Any, Any]) -> None:
             if self.is_done():
                 coro.close()  # cleanup un-awaited coroutine
                 raise InteractionResponded(self._parent)
-            await coro
+            return await coro
 
 
 class _InteractionMessageState:

discord/types/interactions.py

@@ -272,3 +272,26 @@ class EditApplicationCommand(TypedDict):
 _StringApplicationIntegrationType = Literal["0", "1"]
 
 AuthorizingIntegrationOwners = Dict[_StringApplicationIntegrationType, Snowflake]
+
+
+class InteractionCallbackResponse(TypedDict):
+    interaction: InteractionCallback
+    resource: NotRequired[InteractionCallbackResource]
+
+
+class InteractionCallback(TypedDict):
+    id: Snowflake
+    type: InteractionType
+    activity_instance_id: NotRequired[str]
+    response_message_id: NotRequired[Snowflake]
+    response_message_loading: NotRequired[bool]
+    response_message_ephemeral: NotRequired[bool]
+
+
+class InteractionCallbackResource(TypedDict):
+    type: InteractionResponseType
+    # This is not fully typed as activities are out of scope
+    activity_instance: NotRequired[dict]
+    message: NotRequired[Message]
+
+

discord/webhook/async_.py

@@ -537,13 +537,18 @@ def create_interaction_response(
             webhook_token=token,
         )
 
+        params: dict[str, Any] = {
+            "with_response": True,
+        }
+
         return self.request(
             route,
             session=session,
             proxy=proxy,
             proxy_auth=proxy_auth,
             files=files,
             multipart=form,
+            params=params,
         )
 
     def get_original_interaction_response(