Significant-Gravitas · Bentlybro · Sep 7, 2026 · Sep 8, 2026 · Sep 8, 2026 · coderabbitai
@@ -201,6 +201,37 @@ async def send_link(
         """
         ...
 
+    @property
+    def supports_choice_buttons(self) -> bool:
+        """Whether `send_choice_buttons` can render native option buttons.
+
+        Default False — only platforms overriding `send_choice_buttons`
+        below flip this. Checked before spending a `bot.choices` token on a
+        question, so unsupported adapters never pay that cost.
+        """
+        return False
+
+    async def send_choice_buttons(
+        self,
+        channel_id: str,
+        text: str,
+        options: list[str],
+        token: str,
+        mentionable_users: tuple[tuple[str, str], ...] = (),
+    ) -> bool:
+        """Send `text` with native clickable option buttons/select where the
+        platform supports it, returning True once sent.
+
+        A click carries `token` and the clicked option's index (not the
+        option text -- Telegram's callback_data caps at 64 bytes); the
+        adapter resolves it via `bot.choices.resolve_choice` and feeds the
+        resolved text through its own `on_message` callback, exactly as if
+        the user had typed it. Returns False when the platform doesn't
+        implement this (or `options` doesn't fit its native widget), telling
+        the caller to fall back to plain numbered text. Default: unsupported.
+        """
+        return False
+
     @abstractmethod
     async def send_reply(
         self,

@@ -37,7 +37,7 @@
     ReferencedConversation,
     SocketAdapter,
 )
-from . import commands, config, intro
+from . import choice_ui, commands, config, intro
 from .references import (
     ReferenceTarget,
     extract_referenced_targets,
@@ -187,6 +187,29 @@ async def send_link(
         )
         await channel.send(text, view=view, tts=False)
 
+    @property
+    def supports_choice_buttons(self) -> bool:
+        return True
+
+    async def send_choice_buttons(
+        self,
+        channel_id: str,
+        text: str,
+        options: list[str],
+        token: str,
+        mentionable_users: tuple[tuple[str, str], ...] = (),
+    ) -> bool:
+        channel = await self._resolve_channel(channel_id)
+        if channel is None or not isinstance(channel, discord.abc.Messageable):
+            return False
+        if self._on_message_callback is None:
+            return False
+        view = choice_ui.build_choice_view(
+            self, self._on_message_callback, token, options
+        )
+        await channel.send(text, view=view, tts=False)
+        return True
+
     async def send_file(self, channel_id: str, text: str, file: FileAttachment) -> None:
         channel = await self._resolve_channel(channel_id)
         if channel is None or not isinstance(channel, discord.abc.Messageable):

@@ -15,6 +15,7 @@
     _mention_queries,
     _resolve_mentions,
 )
+from backend.copilot.bot.turn_stream import _clarification_message
 
 
 def _bare_adapter(bot_id: int | None = 1000) -> tuple[DiscordAdapter, MagicMock]:
@@ -355,6 +356,59 @@ async def test_send_message_pins_tts_false(self):
         # Default empty mentionable_users → AllowedMentions.none()
         assert isinstance(kwargs["allowed_mentions"], discord.AllowedMentions)
 
+    @pytest.mark.asyncio
+    async def test_send_message_delivers_clarification_question(self):
+        """SECRT-2604: an ask_question payload must reach Discord as a plain
+        text message with the numbered options intact, unmangled by the
+        adapter's real send path (channel.send)."""
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        channel.send = AsyncMock()
+        client.get_channel.return_value = channel
+
+        text = _clarification_message(
+            {"questions": [{"question": "Which region?", "options": ["US", "EU"]}]}
+        )
+        await adapter.send_message("123", text)
+
+        sent = channel.send.await_args.args[0]
+        assert "Which region?" in sent
+        assert "1. US" in sent
+        assert "2. EU" in sent
+        assert "Reply with a number" in sent
+
+    @pytest.mark.asyncio
+    async def test_send_choice_buttons_sends_one_button_per_option(self):
+        adapter, client = _bare_adapter()
+        adapter._on_message_callback = AsyncMock()
+        channel = MagicMock(spec=discord.TextChannel)
+        channel.send = AsyncMock()
+        client.get_channel.return_value = channel
+
+        sent = await adapter.send_choice_buttons(
+            "123", "❓ Which region?", ["US", "EU"], "tok"
+        )
+
+        assert sent is True
+        assert adapter.supports_choice_buttons is True
+        channel.send.assert_awaited_once()
+        args, kwargs = channel.send.await_args
+        assert args == ("❓ Which region?",)
+        view = kwargs["view"]
+        assert [b.label for b in view.children] == ["US", "EU"]
+
+    @pytest.mark.asyncio
+    async def test_send_choice_buttons_returns_false_without_message_callback(self):
+        adapter, client = _bare_adapter()
+        channel = MagicMock(spec=discord.TextChannel)
+        channel.send = AsyncMock()
+        client.get_channel.return_value = channel
+
+        sent = await adapter.send_choice_buttons("123", "❓ Q?", ["US"], "tok")
+
+        assert sent is False
+        channel.send.assert_not_awaited()
+
     @pytest.mark.asyncio
     async def test_send_message_silently_drops_when_channel_missing(self):
         adapter, client = _bare_adapter()

@@ -0,0 +1,88 @@
+"""Native Discord buttons for ask_question, and the click handler that turns
+a press into an ordinary inbound message.
+
+Kept out of ``adapter.py`` (already large) — the only thing the adapter needs
+from here is ``build_choice_view``.
+"""
+
+import logging
+
+import discord
+
+from backend.copilot.bot import choices
+from backend.copilot.bot.adapters.base import (
+    ChannelType,
+    MessageCallback,
+    MessageContext,
+    PlatformAdapter,
+)
+
+logger = logging.getLogger(__name__)
+
+_EXPIRED_NOTICE = "This question has expired — type your answer instead."
+
+
+def build_choice_view(
+    adapter: PlatformAdapter,
+    on_message: MessageCallback,
+    token: str,
+    options: list[str],
+) -> discord.ui.View:
+    """One button per option (View auto-wraps into rows of 5); a click
+    resolves the answer via ``bot.choices`` and feeds it through
+    ``on_message``, exactly like a normal typed reply."""
+    view = discord.ui.View(timeout=choices.CHOICE_TTL)
+    for index, option in enumerate(options):
+        view.add_item(_ChoiceButton(adapter, on_message, token, index, option))
+    return view
+
+
+class _ChoiceButton(discord.ui.Button):
+    def __init__(
+        self,
+        adapter: PlatformAdapter,
+        on_message: MessageCallback,
+        token: str,
+        index: int,
+        label: str,
+    ) -> None:
+        super().__init__(style=discord.ButtonStyle.secondary, label=label[:80])
+        self._adapter = adapter
+        self._on_message = on_message
+        self._token = token
+        self._index = index
+
+    async def callback(self, interaction: discord.Interaction) -> None:
+        option = await choices.resolve_choice("discord", self._token, self._index)
+        if option is None:
+            await interaction.response.send_message(_EXPIRED_NOTICE, ephemeral=True)
+            return
+        await interaction.response.edit_message(
+            content=f"✅ You answered: {option}", view=None
+        )
+        ctx = _context_from_interaction(interaction, option)
+        if ctx is not None:
+            await self._on_message(ctx, self._adapter)
+
+
+def _context_from_interaction(
+    interaction: discord.Interaction, option: str
+) -> MessageContext | None:
+    if interaction.channel_id is None or interaction.user is None:
+        return None
+    channel_type: ChannelType = "channel"
+    if interaction.guild_id is None:
+        channel_type = "dm"
+    elif isinstance(interaction.channel, discord.Thread):
+        channel_type = "thread"
+    return MessageContext(
+        platform="discord",
+        channel_type=channel_type,
+        server_id=str(interaction.guild_id) if interaction.guild_id else None,
+        channel_id=str(interaction.channel_id),
+        message_id=str(interaction.id),
+        user_id=str(interaction.user.id),
+        username=interaction.user.display_name,
+        text=option,
+        bot_mentioned=True,
+    )
@@ -0,0 +1,100 @@
+"""Tests for Discord native choice buttons (SECRT-2604)."""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import discord
+import pytest
+
+from .choice_ui import build_choice_view
+
+_CHOICES = "backend.copilot.bot.adapters.discord.choice_ui.choices"
+
+
+def _interaction(
+    *, channel_id: int = 111, guild_id: int | None = 222, user_id: int = 9
+) -> MagicMock:
+    interaction = MagicMock()
+    interaction.channel_id = channel_id
+    interaction.guild_id = guild_id
+    interaction.channel = MagicMock(spec=discord.TextChannel)
+    interaction.id = 555
+    interaction.user = MagicMock()
+    interaction.user.id = user_id
+    interaction.user.display_name = "Bently"
+    interaction.response = MagicMock()
+    interaction.response.send_message = AsyncMock()
+    interaction.response.edit_message = AsyncMock()
+    return interaction
+
+
+class TestBuildChoiceView:
+    @pytest.mark.asyncio
+    async def test_one_button_per_option(self):
+        adapter = MagicMock()
+        on_message = AsyncMock()
+        view = build_choice_view(adapter, on_message, "tok", ["US", "EU", "AP"])
+        assert len(view.children) == 3
+        assert [b.label for b in view.children] == ["US", "EU", "AP"]
+
+    @pytest.mark.asyncio
+    async def test_labels_truncate_to_discord_button_cap(self):
+        adapter = MagicMock()
+        on_message = AsyncMock()
+        long_label = "x" * 200
+        view = build_choice_view(adapter, on_message, "tok", [long_label])
+        assert len(view.children[0].label) == 80
+
+
+class TestChoiceButtonCallback:
+    @pytest.mark.asyncio
+    async def test_click_resolves_and_dispatches_as_message(self):
+        adapter = MagicMock()
+        on_message = AsyncMock()
+        interaction = _interaction()
+
+        with patch(f"{_CHOICES}.resolve_choice", new=AsyncMock(return_value="EU")):
+            view = build_choice_view(adapter, on_message, "tok", ["US", "EU"])
+            await view.children[1].callback(interaction)
+
+        interaction.response.edit_message.assert_awaited_once_with(
+            content="✅ You answered: EU", view=None
+        )
+        on_message.assert_awaited_once()
+        ctx, dispatched_adapter = on_message.await_args.args
+        assert dispatched_adapter is adapter
+        assert ctx.text == "EU"
+        assert ctx.platform == "discord"
+        assert ctx.channel_id == "111"
+        assert ctx.user_id == "9"
+        assert ctx.username == "Bently"
+        assert ctx.channel_type == "channel"
+        assert ctx.bot_mentioned is True
+
+    @pytest.mark.asyncio
+    async def test_dm_interaction_maps_to_dm_channel_type(self):
+        adapter = MagicMock()
+        on_message = AsyncMock()
+        interaction = _interaction(guild_id=None)
+
+        with patch(f"{_CHOICES}.resolve_choice", new=AsyncMock(return_value="US")):
+            view = build_choice_view(adapter, on_message, "tok", ["US"])
+            await view.children[0].callback(interaction)
+
+        ctx, _ = on_message.await_args.args
+        assert ctx.channel_type == "dm"
+        assert ctx.server_id is None
+
+    @pytest.mark.asyncio
+    async def test_expired_token_shows_ephemeral_notice_and_does_not_dispatch(self):
+        adapter = MagicMock()
+        on_message = AsyncMock()
+        interaction = _interaction()
+
+        with patch(f"{_CHOICES}.resolve_choice", new=AsyncMock(return_value=None)):
+            view = build_choice_view(adapter, on_message, "tok", ["US", "EU"])
+            await view.children[0].callback(interaction)
+
+        interaction.response.send_message.assert_awaited_once()
+        assert "expired" in interaction.response.send_message.await_args.args[0]
+        interaction.response.edit_message.assert_not_awaited()
+        on_message.assert_not_awaited()