Merge remote-tracking branch 'origin/feat/extra-agentspeak-functionality' into feat/monitoringpage-cb

src/control_backend/agents/actuation/robot_gesture_agent.py

@@ -33,7 +33,7 @@ class RobotGestureAgent(BaseAgent):
     def __init__(
         self,
         name: str,
-        address=settings.zmq_settings.ri_command_address,
+        address: str,
         bind=False,
         gesture_data=None,
         single_gesture_data=None,

src/control_backend/agents/bdi/bdi_program_manager.py

@@ -86,6 +86,7 @@ class BDIProgramManager(BaseAgent):
                 self._phase = phase
 
         self._send_beliefs_to_semantic_belief_extractor()
+        self._send_goals_to_semantic_belief_extractor()
 
         # Notify user interaction agent
         msg = InternalMessage(
@@ -132,12 +133,10 @@ class BDIProgramManager(BaseAgent):
 
         await self.send(message)
 
-    @staticmethod
-    def _extract_goals_from_program(program: Program) -> list[Goal]:
+    def _extract_current_goals(self) -> list[Goal]:
         """
         Extract all goals from the program, including subgoals.
 
-        :param program: The program received from the API.
         :return: A list of Goal objects.
         """
         goals: list[Goal] = []
@@ -149,19 +148,16 @@ class BDIProgramManager(BaseAgent):
                     goals_.extend(extract_goals_from_goal(plan))
             return goals_
 
-        for phase in program.phases:
-            for goal in phase.goals:
-                goals.extend(extract_goals_from_goal(goal))
+        for goal in self._phase.goals:
+            goals.extend(extract_goals_from_goal(goal))
 
         return goals
 
-    async def _send_goals_to_semantic_belief_extractor(self, program: Program):
+    async def _send_goals_to_semantic_belief_extractor(self):
         """
-        Extract goals from the program and send them to the Semantic Belief Extractor Agent.
-
-        :param program: The program received from the API.
+        Extract goals for the current phase and send them to the Semantic Belief Extractor Agent.
         """
-        goals = GoalList(goals=self._extract_goals_from_program(program))
+        goals = GoalList(goals=self._extract_current_goals())
 
         message = InternalMessage(
             to=settings.agent_settings.text_belief_extractor_name,
@@ -172,12 +168,34 @@ class BDIProgramManager(BaseAgent):
 
         await self.send(message)
 
+    async def _send_clear_llm_history(self):
+        """
+        Clear the LLM Agent's conversation history.
+
+        Sends an empty history to the LLM Agent to reset its state.
+        """
+        message = InternalMessage(
+            to=settings.agent_settings.llm_name,
+            body="clear_history",
+        )
+        await self.send(message)
+        self.logger.debug("Sent message to LLM agent to clear history.")
+
+        extractor_msg = InternalMessage(
+            to=settings.agent_settings.text_belief_extractor_name,
+            thread="conversation_history",
+            body="reset",
+        )
+        await self.send(extractor_msg)
+        self.logger.debug("Sent message to extractor agent to clear history.")
+
     async def _receive_programs(self):
         """
         Continuous loop that receives program updates from the HTTP endpoint.
 
         It listens to the ``program`` topic on the internal ZMQ SUB socket.
         When a program is received, it is validated and forwarded to BDI via :meth:`_send_to_bdi`.
+        Additionally, the LLM history is cleared via :meth:`_send_clear_llm_history`.
         """
         while True:
             topic, body = await self.sub_socket.recv_multipart()
@@ -190,10 +208,12 @@ class BDIProgramManager(BaseAgent):
 
             self._initialize_internal_state(program)
 
+            await self._send_clear_llm_history()
+
             await asyncio.gather(
                 self._create_agentspeak_and_send_to_bdi(program),
                 self._send_beliefs_to_semantic_belief_extractor(),
-                self._send_goals_to_semantic_belief_extractor(program),
+                self._send_goals_to_semantic_belief_extractor(),
             )
 
     async def setup(self):

src/control_backend/agents/bdi/text_belief_extractor_agent.py

@@ -116,9 +116,19 @@ class TextBeliefExtractorAgent(BaseAgent):
                 self._handle_beliefs_message(msg)
             case "goals":
                 self._handle_goals_message(msg)
+            case "conversation_history":
+                if msg.body == "reset":
+                    self._reset()
             case _:
                 self.logger.warning("Received unexpected message from %s", msg.sender)
 
+    def _reset(self):
+        self.conversation = ChatHistory(messages=[])
+        self.belief_inferrer.available_beliefs.clear()
+        self._current_beliefs = BeliefState()
+        self.goal_inferrer.goals.clear()
+        self._current_goal_completions = {}
+
     def _handle_beliefs_message(self, msg: InternalMessage):
         try:
             belief_list = BeliefList.model_validate_json(msg.body)

src/control_backend/agents/communication/ri_communication_agent.py

@@ -38,7 +38,7 @@ class RICommunicationAgent(BaseAgent):
     def __init__(
         self,
         name: str,
-        address=settings.zmq_settings.ri_command_address,
+        address=settings.zmq_settings.ri_communication_address,
         bind=False,
     ):
         super().__init__(name)
@@ -168,7 +168,7 @@ class RICommunicationAgent(BaseAgent):
             bind = port_data["bind"]
 
             if not bind:
-                addr = f"tcp://localhost:{port}"
+                addr = f"tcp://{settings.ri_host}:{port}"
             else:
                 addr = f"tcp://*:{port}"
 

src/control_backend/agents/llm/llm_agent.py

@@ -57,8 +57,12 @@ class LLMAgent(BaseAgent):
                     self.history.append({"role": "assistant", "content": msg.body})
                 case "user_message":
                     self.history.append({"role": "user", "content": msg.body})
+        elif msg.sender == settings.agent_settings.bdi_program_manager_name:
+            if msg.body == "clear_history":
+                self.logger.debug("Clearing conversation history.")
+                self.history.clear()
         else:
-            self.logger.debug("Message ignored (not from BDI core.")
+            self.logger.debug("Message ignored.")
 
     async def _process_bdi_message(self, message: LLMPromptMessage):
         """

src/control_backend/agents/perception/vad_agent.py

@@ -103,12 +103,11 @@ class VADAgent(BaseAgent):
 
         self._connect_audio_in_socket()
 
-        audio_out_port = self._connect_audio_out_socket()
-        if audio_out_port is None:
+        audio_out_address = self._connect_audio_out_socket()
+        if audio_out_address is None:
             self.logger.error("Could not bind output socket, stopping.")
             await self.stop()
             return
-        audio_out_address = f"tcp://localhost:{audio_out_port}"
 
         # Connect to internal communication socket
         self.program_sub_socket = azmq.Context.instance().socket(zmq.SUB)
@@ -161,13 +160,14 @@ class VADAgent(BaseAgent):
             self.audio_in_socket.connect(self.audio_in_address)
         self.audio_in_poller = SocketPoller[bytes](self.audio_in_socket)
 
-    def _connect_audio_out_socket(self) -> int | None:
+    def _connect_audio_out_socket(self) -> str | None:
         """
-        Returns the port bound, or None if binding failed.
+        Returns the address that was bound to, or None if binding failed.
         """
         try:
             self.audio_out_socket = azmq.Context.instance().socket(zmq.PUB)
-            return self.audio_out_socket.bind_to_random_port("tcp://localhost", max_tries=100)
+            self.audio_out_socket.bind(settings.zmq_settings.vad_pub_address)
+            return settings.zmq_settings.vad_pub_address
         except zmq.ZMQBindError:
             self.logger.error("Failed to bind an audio output socket after 100 tries.")
             self.audio_out_socket = None