refactor: remove SPADE dependencies

Did not look at tests yet, this is a very non-final commit.

ref: N25B-300

src/control_backend/agents/actuation/robot_speech_agent.py

@@ -1,11 +1,10 @@
 import json
 
-import spade.agent
 import zmq
-from spade.behaviour import CyclicBehaviour
-from zmq.asyncio import Context
+import zmq.asyncio as azmq
 
 from control_backend.agents import BaseAgent
+from control_backend.core.agent_system import InternalMessage
 from control_backend.core.config import settings
 from control_backend.schemas.ri_message import SpeechCommand
 
@@ -18,57 +17,21 @@ class RobotSpeechAgent(BaseAgent):
 
     def __init__(
         self,
-        jid: str,
-        password: str,
-        port: int = settings.agent_settings.default_spade_port,
-        verify_security: bool = False,
+        name: str,
         address=settings.zmq_settings.ri_command_address,
         bind=False,
     ):
-        super().__init__(jid, password, port, verify_security)
+        super().__init__(name)
         self.address = address
         self.bind = bind
 
-    class SendZMQCommandsBehaviour(CyclicBehaviour):
-        """Behaviour for sending commands received from the UI."""
-
-        async def run(self):
-            """
-            Run the command publishing loop indefinetely.
-            """
-            assert self.agent is not None
-            # Get a message internally (with topic command)
-            topic, body = await self.agent.subsocket.recv_multipart()
-
-            # Try to get body
-            try:
-                body = json.loads(body)
-                message = SpeechCommand.model_validate(body)
-
-                # Send to the robot.
-                await self.agent.pubsocket.send_json(message.model_dump())
-            except Exception as e:
-                self.agent.logger.error("Error processing message: %s", e)
-
-    class SendSpadeCommandsBehaviour(CyclicBehaviour):
-        """Behaviour for sending commands received from other Python agents."""
-
-        async def run(self):
-            message: spade.agent.Message = await self.receive(timeout=0.1)
-            if message and message.to == self.agent.jid:
-                try:
-                    speech_command = SpeechCommand.model_validate_json(message.body)
-                    await self.agent.pubsocket.send_json(speech_command.model_dump())
-                except Exception as e:
-                    self.agent.logger.error("Error processing message: %s", e)
-
     async def setup(self):
         """
         Setup the robot speech command agent
         """
-        self.logger.info("Setting up %s", self.jid)
+        self.logger.info("Setting up %s", self.name)
 
-        context = Context.instance()
+        context = azmq.Context.instance()
 
         # To the robot
         self.pubsocket = context.socket(zmq.PUB)
@@ -82,9 +45,38 @@ class RobotSpeechAgent(BaseAgent):
         self.subsocket.connect(settings.zmq_settings.internal_sub_address)
         self.subsocket.setsockopt(zmq.SUBSCRIBE, b"command")
 
-        # Add behaviour to our agent
-        commands_behaviour = self.SendZMQCommandsBehaviour()
-        self.add_behaviour(commands_behaviour)
-        self.add_behaviour(self.SendSpadeCommandsBehaviour())
+        await self.add_background_task(self._zmq_command_loop())
 
-        self.logger.info("Finished setting up %s", self.jid)
+        self.logger.info("Finished setting up %s", self.name)
+
+    async def stop(self):
+        if self.subsocket:
+            self.subsocket.close()
+        if self.pubsocket:
+            self.pubsocket.close()
+        await super().stop()
+
+    async def handle_message(self, msg: InternalMessage):
+        """
+        Handle commands received from other Python agents.
+        """
+        try:
+            speech_command = SpeechCommand.model_validate_json(msg.body)
+            await self.pubsocket.send_json(speech_command.model_dump())
+        except Exception:
+            self.logger.exception("Error processing internal message.")
+
+    async def _zmq_command_loop(self):
+        """
+        Handle commands from the UI.
+        """
+        while self._running:
+            try:
+                _, body = await self.subsocket.recv_multipart()
+
+                body = json.loads(body)
+                message = SpeechCommand.model_validate(body)
+
+                await self.pubsocket.send_json(message.model_dump())
+            except Exception:
+                self.logger.exception("Error processing ZMQ message.")