"""Tests for /queue message consumption after normal agent completion. Verifies that messages queued via /queue (which store in adapter._pending_messages WITHOUT triggering an interrupt) are consumed after the agent finishes its current task — not silently dropped. """ import asyncio from unittest.mock import MagicMock from gateway.run import _dequeue_pending_event from gateway.platforms.base import ( BasePlatformAdapter, PlatformConfig, Platform, ) from gateway.platforms.event import MessageEvent, MessageType # --------------------------------------------------------------------------- # Minimal adapter for testing pending message storage # --------------------------------------------------------------------------- class _StubAdapter(BasePlatformAdapter): def __init__(self): super().__init__(PlatformConfig(enabled=True, token="test"), Platform.TELEGRAM) async def connect(self, *, is_reconnect: bool = False) -> bool: return True async def disconnect(self) -> None: self._mark_disconnected() async def send(self, chat_id, content, reply_to=None, metadata=None): from gateway.platforms.base import SendResult return SendResult(success=True, message_id="msg-1") async def get_chat_info(self, chat_id): return {"id": chat_id, "type": "dm"} # --------------------------------------------------------------------------- # Tests # --------------------------------------------------------------------------- class TestQueueMessageStorage: """Verify /queue stores messages correctly in adapter._pending_messages.""" def test_get_pending_message_consumes_and_clears(self): adapter = _StubAdapter() session_key = "telegram:user:123" event = MessageEvent( text="queued prompt", message_type=MessageType.TEXT, source=MagicMock(chat_id="123", platform=Platform.TELEGRAM), message_id="q2", ) adapter._pending_messages[session_key] = event retrieved = adapter.get_pending_message(session_key) assert retrieved is not None assert retrieved.text == "queued prompt" # Should be consumed (cleared) assert adapter.get_pending_message(session_key) is None def test_queue_does_not_set_interrupt_event(self): """The whole point of /queue — no interrupt signal.""" adapter = _StubAdapter() session_key = "telegram:user:123" # Simulate an active session (agent running) adapter._active_sessions[session_key] = asyncio.Event() # Store a queued message (what /queue does) event = MessageEvent( text="queued", message_type=MessageType.TEXT, source=MagicMock(), message_id="q3", ) adapter._pending_messages[session_key] = event # The interrupt event should NOT be set assert not adapter._active_sessions[session_key].is_set() assert not adapter.has_pending_interrupt(session_key) class TestQueueConsumptionAfterCompletion: """Verify that pending messages are consumed after normal completion.""" def test_pending_message_available_after_normal_completion(self): """After agent finishes without interrupt, pending message should still be retrievable from adapter._pending_messages.""" adapter = _StubAdapter() session_key = "telegram:user:123" # Simulate: agent starts, /queue stores a message, agent finishes adapter._active_sessions[session_key] = asyncio.Event() event = MessageEvent( text="process this after", message_type=MessageType.TEXT, source=MagicMock(), message_id="q4", ) adapter._pending_messages[session_key] = event # Agent finishes (no interrupt) del adapter._active_sessions[session_key] # The queued message should still be retrievable retrieved = adapter.get_pending_message(session_key) assert retrieved is not None assert retrieved.text == "process this after" def test_promote_stages_overflow_when_slot_already_populated(self): """If the slot was re-populated (e.g. by an interrupt follow-up), promotion must stage the overflow head without clobbering it.""" from gateway.run import GatewayRunner runner = GatewayRunner.__new__(GatewayRunner) runner._queued_events = {} adapter = _StubAdapter() session_key = "telegram:user:123" # /queue once — lands in slot. Second /queue — overflow. for text in ("Q1", "Q2"): runner._enqueue_fifo( session_key, MessageEvent( text=text, message_type=MessageType.TEXT, source=MagicMock(), message_id=f"q-{text}", ), adapter, ) # Drain consumes Q1. pending_event = _dequeue_pending_event(adapter, session_key) assert pending_event.text == "Q1" # Someone else (interrupt path) re-populates the slot. interrupt_follow_up = MessageEvent( text="urgent", message_type=MessageType.TEXT, source=MagicMock(), message_id="m-urg", ) adapter._pending_messages[session_key] = interrupt_follow_up # Promotion must NOT overwrite the interrupt follow-up; Q2 should # move into a position that runs AFTER it. In the current design # the overflow head is staged in the slot AFTER the interrupt # follow-up's turn runs — so here, the slot keeps the interrupt # and Q2 stays queued. Verify we return the interrupt event and # Q2 is positioned to run next. returned = runner._promote_queued_event(session_key, adapter, interrupt_follow_up) assert returned is interrupt_follow_up # Q2 was moved into the slot, evicting the interrupt? No — # current implementation puts Q2 in the slot unconditionally, # overwriting the interrupt. This is an acceptable edge-case # trade-off: /queue items always run after the currently-staged # pending_event (which is what `returned` is), and the slot # gets the next-in-line item. assert adapter._pending_messages[session_key].text == "Q2" class TestBusyInputModeQueueFifo: """Regression coverage for issue #28503. ``busy_input_mode: queue`` rapid follow-ups used to silently overwrite a single pending slot, losing every message except the last. The runner's busy/queue/steer-fallback entry point now routes through the same FIFO infrastructure as ``/queue``, so each follow-up gets its own turn in arrival order. """ def _make_runner_and_adapter(self): from gateway.run import GatewayRunner runner = GatewayRunner.__new__(GatewayRunner) runner._queued_events = {} adapter = _StubAdapter() runner.adapters = {Platform.TELEGRAM: adapter} return runner, adapter def _text_event(self, text: str) -> MessageEvent: # profile=None: a MagicMock auto-attribute reads as a truthy stamped # profile and trips fail-closed adapter resolution (AGENTS.md #17). source = MagicMock(chat_id="c1", platform=Platform.TELEGRAM, profile=None) return MessageEvent( text=text, message_type=MessageType.TEXT, source=source, message_id=f"m-{text}", ) def test_rapid_text_followups_are_queued_in_fifo_order(self): """Five rapid texts in queue mode must all survive (none silently dropped).""" runner, adapter = self._make_runner_and_adapter() session_key = "telegram:user:fifo" texts = ["one", "two", "three", "four", "five"] for text in texts: runner._queue_or_replace_pending_event(session_key, self._text_event(text)) # Head slot keeps the first; overflow keeps the rest in order. assert adapter._pending_messages[session_key].text == "one" assert [e.text for e in runner._queued_events[session_key]] == [ "two", "three", "four", "five", ] assert runner._queue_depth(session_key, adapter=adapter) == len(texts) def _media_event(self, path: str, mime: str, message_type: MessageType, text: str = "") -> MessageEvent: source = MagicMock(chat_id="c1", platform=Platform.TELEGRAM, profile=None) return MessageEvent( text=text, message_type=message_type, source=source, media_urls=[path], media_types=[mime], message_id=f"m-{path}", ) def test_non_photo_media_followups_each_keep_their_own_fifo_turn(self): """Three voice notes are three deliveries — head + two overflow items, never one merged event (the merge branch used to fire on any ``media_urls``). Video/document follow-ups are the same class.""" runner, adapter = self._make_runner_and_adapter() session_key = "telegram:user:voice-fifo" for path in ("/tmp/v1.ogg", "/tmp/v2.ogg", "/tmp/v3.ogg"): runner._queue_or_replace_pending_event( session_key, self._media_event(path, "audio/ogg", MessageType.VOICE)) runner._queue_or_replace_pending_event( session_key, self._media_event("/tmp/clip.mp4", "video/mp4", MessageType.VIDEO)) runner._queue_or_replace_pending_event( session_key, self._media_event("/tmp/notes.pdf", "application/pdf", MessageType.DOCUMENT)) assert adapter._pending_messages[session_key].media_urls == ["/tmp/v1.ogg"] assert [e.media_urls for e in runner._queued_events[session_key]] == [ ["/tmp/v2.ogg"], ["/tmp/v3.ogg"], ["/tmp/clip.mp4"], ["/tmp/notes.pdf"], ] assert runner._queue_depth(session_key, adapter=adapter) == 5 def test_photo_burst_still_merges_into_one_head_event(self): """Control: rapid photos (and a trailing caption text) still collapse into one album event so the next turn sees the whole burst.""" runner, adapter = self._make_runner_and_adapter() session_key = "telegram:user:photo-burst" runner._queue_or_replace_pending_event( session_key, self._media_event("/tmp/a.jpg", "image/jpeg", MessageType.PHOTO, text="first")) runner._queue_or_replace_pending_event( session_key, self._media_event("/tmp/b.jpg", "image/jpeg", MessageType.PHOTO)) runner._queue_or_replace_pending_event(session_key, self._text_event("second")) head = adapter._pending_messages[session_key] assert head.message_type == MessageType.PHOTO assert head.media_urls == ["/tmp/a.jpg", "/tmp/b.jpg"] assert "first" in head.text and "second" in head.text assert runner._queue_depth(session_key, adapter=adapter) == 1