refactor: remove SPADE dependencies

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

ref: N25B-300

src/control_backend/agents/perception/transcription_agent/transcription_agent.py

@@ -3,10 +3,9 @@ import asyncio
 import numpy as np
 import zmq
 import zmq.asyncio as azmq
-from spade.behaviour import CyclicBehaviour
-from spade.message import Message
 
 from control_backend.agents import BaseAgent
+from control_backend.core.agent_system import InternalMessage
 from control_backend.core.config import settings
 
 from .speech_recognizer import SpeechRecognizer
@@ -19,53 +18,31 @@ class TranscriptionAgent(BaseAgent):
     """
 
     def __init__(self, audio_in_address: str):
-        jid = settings.agent_settings.transcription_name + "@" + settings.agent_settings.host
-        super().__init__(jid, settings.agent_settings.transcription_name)
+        super().__init__(settings.agent_settings.transcription_name)
 
         self.audio_in_address = audio_in_address
         self.audio_in_socket: azmq.Socket | None = None
+        self.speech_recognizer = None
+        self._concurrency = None
 
-    class TranscribingBehaviour(CyclicBehaviour):
-        def __init__(self, audio_in_socket: azmq.Socket):
-            super().__init__()
-            max_concurrent_tasks = settings.behaviour_settings.transcription_max_concurrent_tasks
-            self.audio_in_socket = audio_in_socket
-            self.speech_recognizer = SpeechRecognizer.best_type()
-            self._concurrency = asyncio.Semaphore(max_concurrent_tasks)
+    async def setup(self):
+        self.logger.info("Setting up %s", self.name)
 
-        def warmup(self):
-            """Load the transcription model into memory to speed up the first transcription."""
-            self.speech_recognizer.load_model()
+        self._connect_audio_in_socket()
 
-        async def _transcribe(self, audio: np.ndarray) -> str:
-            async with self._concurrency:
-                return await asyncio.to_thread(self.speech_recognizer.recognize_speech, audio)
+        # Initialize recognizer and semaphore
+        max_concurrent_tasks = settings.behaviour_settings.transcription_max_concurrent_tasks
+        self._concurrency = asyncio.Semaphore(max_concurrent_tasks)
+        self.speech_recognizer = SpeechRecognizer.best_type()
+        self.speech_recognizer.load_model()  # Warmup
 
-        async def _share_transcription(self, transcription: str):
-            """Share a transcription to the other agents that depend on it."""
-            receiver_jids = [
-                settings.agent_settings.text_belief_extractor_name
-                + "@"
-                + settings.agent_settings.host,
-            ]  # Set message receivers here
+        # Start background loop
+        await self.add_background_task(self._transcribing_loop())
 
-            for receiver_jid in receiver_jids:
-                message = Message(to=receiver_jid, body=transcription)
-                await self.send(message)
-
-        async def run(self) -> None:
-            audio = await self.audio_in_socket.recv()
-            audio = np.frombuffer(audio, dtype=np.float32)
-            speech = await self._transcribe(audio)
-            if not speech:
-                self.agent.logger.info("Nothing transcribed.")
-                return
-
-            self.agent.logger.info("Transcribed speech: %s", speech)
-
-            await self._share_transcription(speech)
+        self.logger.info("Finished setting up %s", self.name)
 
     async def stop(self):
+        assert self.audio_in_socket is not None
         self.audio_in_socket.close()
         self.audio_in_socket = None
         return await super().stop()
@@ -75,13 +52,37 @@ class TranscriptionAgent(BaseAgent):
         self.audio_in_socket.setsockopt_string(zmq.SUBSCRIBE, "")
         self.audio_in_socket.connect(self.audio_in_address)
 
-    async def setup(self):
-        self.logger.info("Setting up %s", self.jid)
+    async def _transcribe(self, audio: np.ndarray) -> str:
+        assert self._concurrency is not None and self.speech_recognizer is not None
+        async with self._concurrency:
+            return await asyncio.to_thread(self.speech_recognizer.recognize_speech, audio)
 
-        self._connect_audio_in_socket()
+    async def _share_transcription(self, transcription: str):
+        """Share a transcription to the other agents that depend on it."""
+        receiver_names = [
+            settings.agent_settings.text_belief_extractor_name,
+        ]
 
-        transcribing = self.TranscribingBehaviour(self.audio_in_socket)
-        transcribing.warmup()
-        self.add_behaviour(transcribing)
+        for receiver_name in receiver_names:
+            message = InternalMessage(
+                to=receiver_name,
+                sender=self.name,
+                body=transcription,
+            )
+            await self.send(message)
 
-        self.logger.info("Finished setting up %s", self.jid)
+    async def _transcribing_loop(self) -> None:
+        while self._running:
+            try:
+                assert self.audio_in_socket is not None
+                audio_data = await self.audio_in_socket.recv()
+                audio = np.frombuffer(audio_data, dtype=np.float32)
+                speech = await self._transcribe(audio)
+                if not speech:
+                    self.logger.info("Nothing transcribed.")
+                    continue
+
+                self.logger.info("Transcribed speech: %s", speech)
+                await self._share_transcription(speech)
+            except Exception as e:
+                self.logger.error(f"Error in transcription loop: {e}")