Migrate built-in commands from hand-crafted per-backend strings to FormattedMessage

executor.py — New _extract_attachments() helper converts FormattedImage/FormattedAttachment from a FormattedMessage into base Attachment objects; _coerce_response() now populates Message.attachments when returning a FormattedMessage
echo.py — Replaced manual mention_users() calls with FormattedMessage + UserMention nodes
help.py — Replaced per-backend if/elif rendering (Symphony <expandable-card>, Slack mrkdwn, Discord markdown table) with FormattedMessage + Heading + Table.from_dict_list() that auto-renders for each backend
status.py — Same migration: builds a Table.from_dict_list() of metrics instead of manual **bold** markdown lines
schedule.py — Same migration for the schedule listing
test_command_framework.py — 3 new tests for _coerce_response() covering images in content, file attachments, and mixed content+attachments

Signed-off-by: Tim Paine <3105306+timkpaine@users.noreply.github.com>

Author: timkpaine

csp_bot/bot.py

@@ -126,6 +126,9 @@ def connect(self, channels: GatewayChannels) -> None:
             log.info(f"Fetching bot info for {backend}...")
             self._fetch_bot_info(backend)
 
+        # Inject backends into AgentCommand subclasses
+        self._inject_backends_into_agent_commands()
+
         # Subscribe to messages from all adapters
         # chatom provides unified Message type across all backends
         messages_in = csp.null_ts(Message)
@@ -248,6 +251,53 @@ def _update_user_access_loop(self, backend: str) -> None:
             except Exception:
                 log.exception(f"Error updating user access for {backend}")
 
+    def _inject_backends_into_agent_commands(self) -> None:
+        """Inject connected BackendBase instances into AgentCommand subclasses."""
+        try:
+            from csp_bot.commands.agent import AgentCommand
+        except ImportError:
+            # pydantic-ai / chatom[agent] not installed — skip silently
+            return
+
+        backends = {}
+        loops = {}
+        for name in self._adapters:
+            result = self._ensure_backend_connected(name)
+            if result:
+                connected_backend, loop = result
+                backends[name] = connected_backend
+                loops[name] = loop
+        if backends:
+            AgentCommand.set_backends(backends, loops=loops)
+            log.info(f"Injected {len(backends)} connected backends into AgentCommand: {list(backends.keys())}")
+
+    def _track_agent_session_response(self, response: Message, command: BotCommand) -> None:
+        """Associate a sent response with an agent session for reply tracking.
+
+        Uses the original command's message ID as the key that future replies
+        will reference (e.g., thread_ts in Slack, or message reference in Discord).
+        """
+        metadata = response.metadata or {}
+        session_key = metadata.get("agent_session_key")
+        if not session_key:
+            return
+
+        try:
+            from csp_bot.commands.agent import AgentCommand
+        except ImportError:
+            return
+
+        # Use the original command's message ID — in Slack threads, replies
+        # reference this as thread_ts; in Discord, as message_reference.
+        orig_msg_id = command.message.id if command.message else None
+        if orig_msg_id:
+            AgentCommand._sessions.update_response_id(session_key, orig_msg_id)
+            log.debug(f"Tracked agent session response: session={session_key}, msg_id={orig_msg_id}")
+
+        # Also track by the response message ID if it has one
+        if response.id and response.id != orig_msg_id:
+            AgentCommand._sessions.update_response_id(session_key, response.id)
+
     def _ensure_backend_connected(self, backend: str) -> Optional[Tuple[Any, asyncio.AbstractEventLoop]]:
         """Ensure a connected backend exists for the given platform.
 
@@ -579,6 +629,8 @@ def _handle_commands(self, cmd: ts[BotCommand]) -> Outputs(messages=ts[[Message]
                         if isinstance(item, Message):
                             log.debug(f"Adding message to buffer: {item.content[:100] if item.content else 'empty'}...")
                             s_buffer.append(item)
+                            # Track agent session responses for reply continuity
+                            self._track_agent_session_response(item, command)
                         elif isinstance(item, BotCommand):
                             next_cycle_commands.append(item)
                 else:
@@ -821,6 +873,11 @@ def _extract_commands(
 
             # Check for command syntax (supports both / and ! prefixes)
             if not content.startswith("/") and not content.startswith("!"):
+                # Check if this is a reply to an active agent session
+                session_cmd = self._check_agent_session_reply(msg, backend, channel_id)
+                if session_cmd:
+                    return session_cmd
+
                 # If tagged but no command, show help
                 log.info("No command prefix, showing help")
                 return self._create_help_command(msg, backend, channel_id)
@@ -914,6 +971,79 @@ def _extract_commands(
             log.exception("Error extracting command")
             return None
 
+    def _check_agent_session_reply(self, msg: Message, backend: str, channel_id: str) -> Optional[BotCommand]:
+        """Check if the message is a reply to a bot response with an active agent session.
+
+        If so, constructs a BotCommand to continue the conversation.
+        """
+        try:
+            from csp_bot.commands.agent import AgentCommand
+        except ImportError:
+            return None
+
+        # Get the referenced message ID
+        ref_id = None
+        if msg.reference and msg.reference.message_id:
+            ref_id = msg.reference.message_id
+        elif msg.reply_to and msg.reply_to.id:
+            ref_id = msg.reply_to.id
+        # Check thread metadata (Slack thread_ts)
+        if not ref_id and msg.thread and msg.thread.id:
+            ref_id = msg.thread.id
+
+        if not ref_id:
+            return None
+
+        # Look up session by the bot response ID
+        session = AgentCommand._sessions.get_by_response_id(ref_id)
+        if session is None:
+            return None
+
+        # Found an active session — route the reply to the same command
+        command_name = session.command_name
+        if command_name not in self._commands:
+            log.warning(f"Agent session references unknown command: {command_name}")
+            return None
+
+        command_runner = self._commands[command_name]
+        content = msg.content or ""
+        # Strip bot mention if present
+        bot_name = self._get_bot_name(backend)
+        bot_id = self._get_bot_id(backend)
+        if bot_id:
+            content = re.sub(rf"<@!?{re.escape(bot_id)}>", "", content).strip()
+        if bot_name and content.startswith(f"@{bot_name}"):
+            content = content[len(f"@{bot_name}") :].strip()
+
+        source = User(
+            id=msg.author.id if msg.author else msg.author_id or "",
+            name=msg.author.name if msg.author else "",
+            email=getattr(msg.author, "email", "") if msg.author else "",
+            handle=getattr(msg.author, "handle", "") if msg.author else "",
+        )
+
+        channel_name = ""
+        if msg.channel and hasattr(msg.channel, "name"):
+            channel_name = msg.channel.name or ""
+
+        bot_cmd = BotCommand(
+            command=command_name,
+            args=(content,),
+            source=source,
+            targets=(),
+            channel_id=channel_id,
+            channel_name=channel_name,
+            backend=backend,
+            variant=command_runner.kind() if isinstance(command_runner, BaseCommand) else CommandVariant.REPLY,
+            message=msg,
+            delay=None,
+            schedule="",
+            times_run=0,
+        )
+
+        log.info(f"Routing reply to active agent session: command={command_name}, user={source.id}")
+        return command_runner.preexecute(bot_cmd)
+
     def _parse_command_args(
         self,
         tokens: List[str],

csp_bot/commands/__init__.py

@@ -32,6 +32,11 @@
 from .schedule import ScheduleCommand, ScheduleCommandModel
 from .status import StatusCommand, StatusCommandModel
 
+try:
+    from .agent import AgentCommand
+except ImportError:
+    pass
+
 __all__ = (
     # New framework
     "Command",
@@ -45,6 +50,7 @@
     "get_registered_commands",
     "execute_command_func",
     # Legacy base classes
+    "AgentCommand",
     "BaseCommand",
     "BaseCommandModel",
     "NoResponseCommand",