refactor: similify message pipeline

Author: damassi

docs/architecture.md

@@ -118,7 +118,7 @@ Modal prompt for tool permission requests:
 - Manages focus to prevent input elsewhere while visible
 
 **ChatHistory** (`components/chat_history.py`)
-Container for message widgets, handles `MessagePosted` events.
+Container for message widgets.
 
 **ThinkingIndicator** (`components/thinking_indicator.py`)
 Animated indicator shown during agent processing.

src/agent_chat_cli/app.py

@@ -5,7 +5,7 @@
 from textual.binding import Binding
 
 from agent_chat_cli.components.header import Header
-from agent_chat_cli.components.chat_history import ChatHistory, MessagePosted
+from agent_chat_cli.components.chat_history import ChatHistory
 from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
 from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.components.user_input import UserInput
@@ -49,9 +49,6 @@ def compose(self) -> ComposeResult:
     async def on_mount(self) -> None:
         asyncio.create_task(self.agent_loop.start())
 
-    async def on_message_posted(self, event: MessagePosted) -> None:
-        await self.message_bus.on_message_posted(event)
-
     async def action_interrupt(self) -> None:
         await self.actions.interrupt()
 

src/agent_chat_cli/components/chat_history.py

@@ -1,6 +1,5 @@
 import json
 from textual.containers import Container
-from textual.message import Message as TextualMessage
 
 from agent_chat_cli.components.messages import (
     AgentMessage,
@@ -48,9 +47,3 @@ def _create_message_widget(
                     tool_widget.tool_input = {"raw": message.content}
 
                 return tool_widget
-
-
-class MessagePosted(TextualMessage):
-    def __init__(self, message: Message) -> None:
-        self.message = message
-        super().__init__()

src/agent_chat_cli/core/actions.py

@@ -1,8 +1,11 @@
+import asyncio
 from typing import TYPE_CHECKING
 
+from textual.containers import VerticalScroll
+
 from agent_chat_cli.utils.enums import ControlCommand
-from agent_chat_cli.components.chat_history import ChatHistory, MessagePosted
-from agent_chat_cli.components.messages import Message
+from agent_chat_cli.components.chat_history import ChatHistory
+from agent_chat_cli.components.messages import Message, MessageType
 from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.utils.logger import log_json
 
@@ -17,13 +20,33 @@ def __init__(self, app: "AgentChatCLIApp") -> None:
     def quit(self) -> None:
         self.app.exit()
 
+    async def add_message_to_chat(self, type: MessageType, content: str) -> None:
+        match type:
+            case MessageType.USER:
+                message = Message.user(content)
+            case MessageType.SYSTEM:
+                message = Message.system(content)
+            case MessageType.AGENT:
+                message = Message.agent(content)
+            case _:
+                raise ValueError(f"Unsupported message type: {type}")
+
+        chat_history = self.app.query_one(ChatHistory)
+        chat_history.add_message(message)
+        await self._scroll_to_bottom()
+
+    async def _scroll_to_bottom(self) -> None:
+        await asyncio.sleep(0.1)
+        container = self.app.query_one(VerticalScroll)
+        container.scroll_end(animate=False, immediate=True)
+
     async def submit_user_message(self, message: str) -> None:
-        self.app.post_message(MessagePosted(Message.user(message)))
+        await self.add_message_to_chat(MessageType.USER, message)
         self.app.ui_state.start_thinking()
         await self._query(message)
 
-    def post_system_message(self, message: str) -> None:
-        self.app.post_message(MessagePosted(Message.system(message)))
+    async def post_system_message(self, message: str) -> None:
+        await self.add_message_to_chat(MessageType.SYSTEM, message)
 
     async def handle_agent_message(self, message) -> None:
         await self.app.message_bus.handle_agent_message(message)

src/agent_chat_cli/core/agent_loop.py

@@ -213,7 +213,7 @@ async def _can_use_tool(
                 )
 
             if rejected_tool:
-                self.app.actions.post_system_message(
+                await self.app.actions.post_system_message(
                     f"Permission denied for {tool_name}"
                 )
 

src/agent_chat_cli/core/message_bus.py

@@ -4,10 +4,10 @@
 from textual.widgets import Markdown
 from textual.containers import VerticalScroll
 
-from agent_chat_cli.components.chat_history import ChatHistory, MessagePosted
+from agent_chat_cli.components.chat_history import ChatHistory
 from agent_chat_cli.components.messages import (
     AgentMessage as AgentMessageWidget,
-    Message,
+    MessageType,
     ToolMessage,
 )
 from agent_chat_cli.core.agent_loop import AgentMessage
@@ -44,12 +44,6 @@ async def handle_agent_message(self, message: AgentMessage) -> None:
             case AgentMessageType.RESULT:
                 await self._handle_result()
 
-    async def on_message_posted(self, event: MessagePosted) -> None:
-        chat_history = self.app.query_one(ChatHistory)
-        chat_history.add_message(event.message)
-
-        await self._scroll_to_bottom()
-
     async def _handle_stream_event(self, message: AgentMessage) -> None:
         text_chunk = message.data.get("text", "")
 
@@ -103,20 +97,13 @@ async def _handle_system(self, message: AgentMessage) -> None:
         system_content = (
             message.data if isinstance(message.data, str) else str(message.data)
         )
-
-        # Dispatch message
-        self.app.post_message(MessagePosted(Message.system(system_content)))
-
-        await self._scroll_to_bottom()
+        await self.app.actions.add_message_to_chat(MessageType.SYSTEM, system_content)
 
     async def _handle_user(self, message: AgentMessage) -> None:
         user_content = (
             message.data if isinstance(message.data, str) else str(message.data)
         )
-
-        self.app.post_message(MessagePosted(Message.user(user_content)))
-
-        await self._scroll_to_bottom()
+        await self.app.actions.add_message_to_chat(MessageType.USER, user_content)
 
     async def _handle_tool_permission_request(self, message: AgentMessage) -> None:
         log_json(

src/agent_chat_cli/docs/architecture.md

@@ -74,7 +74,7 @@ User Input
     ↓
 UserInput.on_input_submitted
     ↓
-MessagePosted event → ChatHistory (immediate UI update)
+Actions.add_message_to_chat → ChatHistory (immediate UI update)
     ↓
 Actions.query(user_input) → AgentLoop.query_queue.put()
     ↓
@@ -299,10 +299,8 @@ SDK reconnects to previous session with full history
 
 ### User Message Flow
 1. User submits text → UserInput
-2. MessagePosted event → App
-3. App → MessageBus.on_message_posted
-4. MessageBus → ChatHistory.add_message
-5. MessageBus → Scroll to bottom
+2. Actions.add_message_to_chat → ChatHistory.add_message
+3. Scroll to bottom
 
 ### Agent Response Flow
 1. AgentLoop receives SDK message

tests/core/test_actions.py

@@ -3,6 +3,12 @@
 
 from agent_chat_cli.app import AgentChatCLIApp
 from agent_chat_cli.components.chat_history import ChatHistory
+from agent_chat_cli.components.messages import (
+    MessageType,
+    SystemMessage,
+    UserMessage,
+    AgentMessage,
+)
 from agent_chat_cli.components.tool_permission_prompt import ToolPermissionPrompt
 from agent_chat_cli.utils.enums import ControlCommand
 
@@ -30,6 +36,90 @@ def mock_config():
         yield mock
 
 
+class TestActionsAddMessageToChat:
+    async def test_adds_user_message(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+
+            await app.actions.add_message_to_chat(MessageType.USER, "Hello")
+
+            widgets = chat_history.query(UserMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "Hello"
+
+    async def test_adds_system_message(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+
+            await app.actions.add_message_to_chat(MessageType.SYSTEM, "System alert")
+
+            widgets = chat_history.query(SystemMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "System alert"
+
+    async def test_adds_agent_message(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+
+            await app.actions.add_message_to_chat(MessageType.AGENT, "I can help")
+
+            widgets = chat_history.query(AgentMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "I can help"
+
+    async def test_raises_for_unsupported_type(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            with pytest.raises(ValueError, match="Unsupported message type"):
+                await app.actions.add_message_to_chat(MessageType.TOOL, "tool content")
+
+
+class TestActionsPostSystemMessage:
+    async def test_adds_system_message_to_chat(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+
+            await app.actions.post_system_message("Connection established")
+
+            widgets = chat_history.query(SystemMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "Connection established"
+
+
+class TestActionsSubmitUserMessage:
+    async def test_adds_user_message_to_chat(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            chat_history = app.query_one(ChatHistory)
+
+            await app.actions.submit_user_message("Hello agent")
+
+            widgets = chat_history.query(UserMessage)
+            assert len(widgets) == 1
+            assert widgets.first().message == "Hello agent"
+
+    async def test_starts_thinking_indicator(self, mock_agent_loop, mock_config):
+        from agent_chat_cli.components.thinking_indicator import ThinkingIndicator
+
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            await app.actions.submit_user_message("Hello agent")
+
+            thinking_indicator = app.query_one(ThinkingIndicator)
+            assert thinking_indicator.is_thinking is True
+
+    async def test_queues_message_to_agent_loop(self, mock_agent_loop, mock_config):
+        app = AgentChatCLIApp()
+        async with app.run_test():
+            await app.actions.submit_user_message("Hello agent")
+
+            mock_agent_loop.query_queue.put.assert_called_with("Hello agent")
+
+
 class TestActionsInterrupt:
     async def test_sets_interrupting_flag(self, mock_agent_loop, mock_config):
         app = AgentChatCLIApp()

tests/core/test_agent_loop.py

@@ -21,7 +21,7 @@ def mock_app():
     app.ui_state = MagicMock()
     app.actions = MagicMock()
     app.actions.handle_agent_message = AsyncMock()
-    app.actions.post_system_message = MagicMock()
+    app.actions.post_system_message = AsyncMock()
     return app