feat: intitial commit, containing comments for myself

ref: N25B-401

.env.example

@@ -0,0 +1,20 @@
+# Example .env file. To use, make a copy, call it ".env" (i.e. removing the ".example" suffix), then you edit values.
+
+# The hostname of the Robot Interface. Change if the Control Backend and Robot Interface are running on different computers.
+RI_HOST="localhost"
+
+# URL for the local LLM API. Must be an API that implements the OpenAI Chat Completions API, but most do.
+LLM_SETTINGS__LOCAL_LLM_URL="http://localhost:1234/v1/chat/completions"
+
+# Name of the local LLM model to use.
+LLM_SETTINGS__LOCAL_LLM_MODEL="gpt-oss"
+
+# Number of non-speech chunks to wait before speech ended. A chunk is approximately 31 ms. Increasing this number allows longer pauses in speech, but also increases response time.
+BEHAVIOUR_SETTINGS__VAD_NON_SPEECH_PATIENCE_CHUNKS=3
+
+# Timeout in milliseconds for socket polling. Increase this number if network latency/jitter is high, often the case when using Wi-Fi. Perhaps 500 ms. A symptom of this issue is transcriptions getting cut off.
+BEHAVIOUR_SETTINGS__SOCKET_POLLER_TIMEOUT_MS=100
+
+
+
+# For an exhaustive list of options, see the control_backend.core.config module in the docs.

.gitlab/merge_request_templates/default.md

@@ -0,0 +1,9 @@
+%{first_multiline_commit_description}
+
+To verify:
+
+- [ ] Style checks pass
+- [ ] Pipeline (tests) pass
+- [ ] Documentation is up to date
+- [ ] Tests are up to date (new code is covered)
+- [ ] ...

.logging_config.yaml

@@ -1,5 +1,7 @@
 version: 1
 
+# Maak nieuwe (obvervation action)
+# tussen 20-30
 custom_levels:
   OBSERVATION: 25
   ACTION: 26
@@ -19,6 +21,8 @@ formatters:
     format: "{name} {levelname} {levelno} {message} {created} {relativeCreated}"
     style: "{"
 
+# Maak class = logging.fileHandler
+# 
 handlers:
   console:
     class: logging.StreamHandler
@@ -35,6 +39,8 @@ root:
   level: WARN
   handlers: [console]
 
+# Maak research logger, laagste level (21)
+# Handler: UI Handler
 loggers:
   control_backend:
     level: LLM

README.md

@@ -27,6 +27,7 @@ This + part might differ based on what model you choose.
 copy the model name in the module loaded and replace local_llm_modelL. In settings.
 
 
+
 ## Running
 To run the project (development server), execute the following command (while inside the root repository):
 
@@ -34,6 +35,14 @@ To run the project (development server), execute the following command (while in
 uv run fastapi dev src/control_backend/main.py
 ```
 
+### Environment Variables
+
+You can use environment variables to change settings. Make a copy of the [`.env.example`](.env.example) file, name it `.env` and put it in the root directory. The file itself describes how to do the configuration.
+
+For an exhaustive list of environment options, see the `control_backend.core.config` module in the docs.
+
+
+
 ## Testing
 Testing happens automatically when opening a merge request to any branch. If you want to manually run the test suite, you can do so by running the following for unit tests:
 

src/control_backend/agents/actuation/robot_gesture_agent.py

@@ -28,15 +28,18 @@ class RobotGestureAgent(BaseAgent):
     address = ""
     bind = False
     gesture_data = []
+    single_gesture_data = []
 
     def __init__(
         self,
         name: str,
-        address=settings.zmq_settings.ri_command_address,
+        address: str,
         bind=False,
         gesture_data=None,
+        single_gesture_data=None,
     ):
         self.gesture_data = gesture_data or []
+        self.single_gesture_data = single_gesture_data or []
         super().__init__(name)
         self.address = address
         self.bind = bind
@@ -99,7 +102,13 @@ class RobotGestureAgent(BaseAgent):
                         gesture_command.data,
                     )
                     return
-
+            elif gesture_command.endpoint == RIEndpoint.GESTURE_SINGLE:
+                if gesture_command.data not in self.single_gesture_data:
+                    self.logger.warning(
+                        "Received gesture '%s' which is not in available gestures. Early returning",
+                        gesture_command.data,
+                    )
+                    return
             await self.pubsocket.send_json(gesture_command.model_dump())
         except Exception:
             self.logger.exception("Error processing internal message.")

src/control_backend/agents/bdi/bdi_program_manager.py

@@ -60,24 +60,41 @@ class BDIProgramManager(BaseAgent):
         await self.send(message)
         self.logger.debug("Sent new norms and goals to the BDI agent.")
 
+    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,
+            sender=self.name,
+            body="clear_history",
+            threads="clear history message",
+        )
+        await self.send(message)
+        self.logger.debug("Sent message to LLM 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()
 
             try:
                 program = Program.model_validate_json(body)
+                await self._send_to_bdi(program)
+                await self._send_clear_llm_history()
+
             except ValidationError:
                 self.logger.exception("Received an invalid program.")
                 continue
 
-            await self._send_to_bdi(program)
-
     async def setup(self):
         """
         Initialize the agent.

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}"
 
@@ -182,6 +182,7 @@ class RICommunicationAgent(BaseAgent):
                             self._req_socket.bind(addr)
                 case "actuation":
                     gesture_data = port_data.get("gestures", [])
+                    single_gesture_data = port_data.get("single_gestures", [])
                     robot_speech_agent = RobotSpeechAgent(
                         settings.agent_settings.robot_speech_name,
                         address=addr,
@@ -192,6 +193,7 @@ class RICommunicationAgent(BaseAgent):
                         address=addr,
                         bind=bind,
                         gesture_data=gesture_data,
+                        single_gesture_data=single_gesture_data,
                     )
                     await robot_speech_agent.start()
                     await asyncio.sleep(0.1)  # Small delay

src/control_backend/agents/llm/llm_agent.py

@@ -52,6 +52,10 @@ class LLMAgent(BaseAgent):
                 await self._process_bdi_message(prompt_message)
             except ValidationError:
                 self.logger.debug("Prompt message from BDI core is invalid.")
+        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.")
 

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()
+        audio_out_address = self._connect_audio_out_socket()
-        if audio_out_port is None:
+        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

src/control_backend/agents/user_interrupt/user_interrupt_agent.py

@@ -0,0 +1,146 @@
+import json
+
+import zmq
+from zmq.asyncio import Context
+
+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 GestureCommand, RIEndpoint, SpeechCommand
+
+
+class UserInterruptAgent(BaseAgent):
+    """
+    User Interrupt Agent.
+
+    This agent receives button_pressed events from the external HTTP API
+    (via ZMQ) and uses the associated context to trigger one of the following actions:
+
+    - Send a prioritized message to the `RobotSpeechAgent`
+    - Send a prioritized gesture to the `RobotGestureAgent`
+    - Send a belief override to the `BDIProgramManager`in order to activate a
+        trigger/conditional norm or complete a goal.
+
+    Prioritized actions clear the current RI queue before inserting the new item,
+    ensuring they are executed immediately after Pepper's current action has been fulfilled.
+
+    :ivar sub_socket: The ZMQ SUB socket used to receive user intterupts.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.sub_socket = None
+
+    async def _receive_button_event(self):
+        """
+        The behaviour of the UserInterruptAgent.
+        Continuous loop that receives button_pressed events from the button_pressed HTTP endpoint.
+        These events contain a type and a context.
+
+        These are the different types and contexts:
+        - type: "speech", context: string that the robot has to say.
+        - type: "gesture", context: single gesture name that the robot has to perform.
+        - type: "override", context: belief_id that overrides the goal/trigger/conditional norm.
+        """
+        while True:
+            topic, body = await self.sub_socket.recv_multipart()
+
+            try:
+                event_data = json.loads(body)
+                event_type = event_data.get("type")  # e.g., "speech", "gesture"
+                event_context = event_data.get("context")  # e.g., "Hello, I am Pepper!"
+            except json.JSONDecodeError:
+                self.logger.error("Received invalid JSON payload on topic %s", topic)
+                continue
+
+            if event_type == "speech":
+                await self._send_to_speech_agent(event_context)
+                self.logger.info(
+                    "Forwarded button press (speech) with context '%s' to RobotSpeechAgent.",
+                    event_context,
+                )
+            elif event_type == "gesture":
+                await self._send_to_gesture_agent(event_context)
+                self.logger.info(
+                    "Forwarded button press (gesture) with context '%s' to RobotGestureAgent.",
+                    event_context,
+                )
+            elif event_type == "override":
+                await self._send_to_program_manager(event_context)
+                self.logger.info(
+                    "Forwarded button press (override) with context '%s' to BDIProgramManager.",
+                    event_context,
+                )
+            else:
+                self.logger.warning(
+                    "Received button press with unknown type '%s' (context: '%s').",
+                    event_type,
+                    event_context,
+                )
+
+    async def _send_to_speech_agent(self, text_to_say: str):
+        """
+        method to send prioritized speech command to RobotSpeechAgent.
+
+        :param text_to_say: The string that the robot has to say.
+        """
+        cmd = SpeechCommand(data=text_to_say, is_priority=True)
+        out_msg = InternalMessage(
+            to=settings.agent_settings.robot_speech_name,
+            sender=self.name,
+            body=cmd.model_dump_json(),
+        )
+        await self.send(out_msg)
+
+    async def _send_to_gesture_agent(self, single_gesture_name: str):
+        """
+        method to send prioritized gesture command to RobotGestureAgent.
+
+        :param single_gesture_name: The gesture tag that the robot has to perform.
+        """
+        # the endpoint is set to always be GESTURE_SINGLE for user interrupts
+        cmd = GestureCommand(
+            endpoint=RIEndpoint.GESTURE_SINGLE, data=single_gesture_name, is_priority=True
+        )
+        out_msg = InternalMessage(
+            to=settings.agent_settings.robot_gesture_name,
+            sender=self.name,
+            body=cmd.model_dump_json(),
+        )
+        await self.send(out_msg)
+
+    async def _send_to_program_manager(self, belief_id: str):
+        """
+        Send a button_override belief to the BDIProgramManager.
+
+        :param belief_id: The belief_id that overrides the goal/trigger/conditional norm.
+        this id can belong to a basic belief or an inferred belief.
+        See also: https://utrechtuniversity.youtrack.cloud/articles/N25B-A-27/UI-components
+        """
+        data = {"belief": belief_id}
+        message = InternalMessage(
+            to=settings.agent_settings.bdi_program_manager_name,
+            sender=self.name,
+            body=json.dumps(data),
+            thread="belief_override_id",
+        )
+        await self.send(message)
+        self.logger.info(
+            "Sent button_override belief with id '%s' to Program manager.",
+            belief_id,
+        )
+
+    async def setup(self):
+        """
+        Initialize the agent.
+
+        Connects the internal ZMQ SUB socket and subscribes to the 'button_pressed' topic.
+        Starts the background behavior to receive the user interrupts.
+        """
+        context = Context.instance()
+
+        self.sub_socket = context.socket(zmq.SUB)
+        self.sub_socket.connect(settings.zmq_settings.internal_sub_address)
+        self.sub_socket.subscribe("button_pressed")
+
+        self.add_behavior(self._receive_button_event())

src/control_backend/api/v1/endpoints/button_pressed.py

@@ -0,0 +1,31 @@
+import logging
+
+from fastapi import APIRouter, Request
+
+from control_backend.schemas.events import ButtonPressedEvent
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+@router.post("/button_pressed", status_code=202)
+async def receive_button_event(event: ButtonPressedEvent, request: Request):
+    """
+    Endpoint to handle external button press events.
+
+    Validates the event payload and publishes it to the internal 'button_pressed' topic.
+    Subscribers (in this case user_interrupt_agent) will pick this up to trigger
+    specific behaviors or state changes.
+
+    :param event: The parsed ButtonPressedEvent object.
+    :param request: The FastAPI request object.
+    """
+    logger.debug("Received button event: %s | %s", event.type, event.context)
+
+    topic = b"button_pressed"
+    body = event.model_dump_json().encode()
+
+    pub_socket = request.app.state.endpoints_pub_socket
+    await pub_socket.send_multipart([topic, body])
+
+    return {"status": "Event received"}

src/control_backend/api/v1/router.py

@@ -1,6 +1,6 @@
 from fastapi.routing import APIRouter
 
-from control_backend.api.v1.endpoints import logs, message, program, robot, sse
+from control_backend.api.v1.endpoints import button_pressed, logs, message, program, robot, sse
 
 api_router = APIRouter()
 
@@ -13,3 +13,5 @@ api_router.include_router(robot.router, prefix="/robot", tags=["Pings", "Command
 api_router.include_router(logs.router, tags=["Logs"])
 
 api_router.include_router(program.router, tags=["Program"])
+
+api_router.include_router(button_pressed.router, tags=["Button Pressed Events"])

src/control_backend/core/config.py

@@ -1,3 +1,12 @@
+"""
+An exhaustive overview of configurable options. All of these can be set using environment variables
+by nesting with double underscores (__). Start from the ``Settings`` class.
+
+For example, ``settings.ri_host`` becomes ``RI_HOST``, and
+``settings.zmq_settings.ri_communication_address`` becomes
+``ZMQ_SETTINGS__RI_COMMUNICATION_ADDRESS``.
+"""
+
 from pydantic import BaseModel
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -8,16 +17,17 @@ class ZMQSettings(BaseModel):
 
     :ivar internal_pub_address: Address for the internal PUB socket.
     :ivar internal_sub_address: Address for the internal SUB socket.
-    :ivar ri_command_address: Address for sending commands to the Robot Interface.
+    :ivar ri_communication_address: Address for the endpoint that the Robot Interface connects to.
-    :ivar ri_communication_address: Address for receiving communication from the Robot Interface.
+    :ivar vad_pub_address: Address that the VAD agent binds to and publishes audio segments to.
-    :ivar vad_agent_address: Address for the Voice Activity Detection (VAD) agent.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     internal_pub_address: str = "tcp://localhost:5560"
     internal_sub_address: str = "tcp://localhost:5561"
-    ri_command_address: str = "tcp://localhost:0000"
     ri_communication_address: str = "tcp://*:5555"
     internal_gesture_rep_adress: str = "tcp://localhost:7788"
+    vad_pub_address: str = "inproc://vad_stream"
 
 
 class AgentSettings(BaseModel):
@@ -36,6 +46,8 @@ class AgentSettings(BaseModel):
     :ivar robot_speech_name: Name of the Robot Speech Agent.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     # agent names
     bdi_core_name: str = "bdi_core_agent"
     bdi_belief_collector_name: str = "belief_collector_agent"
@@ -48,6 +60,7 @@ class AgentSettings(BaseModel):
     ri_communication_name: str = "ri_communication_agent"
     robot_speech_name: str = "robot_speech_agent"
     robot_gesture_name: str = "robot_gesture_agent"
+    user_interrupt_name: str = "user_interrupt_agent"
 
 
 class BehaviourSettings(BaseModel):
@@ -66,6 +79,8 @@ class BehaviourSettings(BaseModel):
     :ivar transcription_token_buffer: Buffer for transcription tokens.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     sleep_s: float = 1.0
     comm_setup_max_retries: int = 5
     socket_poller_timeout_ms: int = 100
@@ -90,6 +105,8 @@ class LLMSettings(BaseModel):
     :ivar local_llm_model: Name of the local LLM model to use.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     local_llm_url: str = "http://localhost:1234/v1/chat/completions"
     local_llm_model: str = "gpt-oss"
 
@@ -103,6 +120,8 @@ class VADSettings(BaseModel):
     :ivar sample_rate_hz: Sample rate in Hz for the VAD model.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     repo_or_dir: str = "snakers4/silero-vad"
     model_name: str = "silero_vad"
     sample_rate_hz: int = 16000
@@ -116,6 +135,8 @@ class SpeechModelSettings(BaseModel):
     :ivar openai_model_name: Model name for OpenAI-based speech recognition.
     """
 
+    # ATTENTION: When adding/removing settings, make sure to update the .env.example file
+
     # model identifiers for speech recognition
     mlx_model_name: str = "mlx-community/whisper-small.en-mlx"
     openai_model_name: str = "small.en"
@@ -127,6 +148,7 @@ class Settings(BaseSettings):
 
     :ivar app_title: Title of the application.
     :ivar ui_url: URL of the frontend UI.
+    :ivar ri_host: The hostname of the Robot Interface.
     :ivar zmq_settings: ZMQ configuration.
     :ivar agent_settings: Agent name configuration.
     :ivar behaviour_settings: Behavior configuration.
@@ -139,6 +161,8 @@ class Settings(BaseSettings):
 
     ui_url: str = "http://localhost:5173"
 
+    ri_host: str = "localhost"
+
     zmq_settings: ZMQSettings = ZMQSettings()
 
     agent_settings: AgentSettings = AgentSettings()

src/control_backend/main.py

@@ -39,6 +39,9 @@ from control_backend.agents.communication import RICommunicationAgent
 # LLM Agents
 from control_backend.agents.llm import LLMAgent
 
+# User Interrupt Agent
+from control_backend.agents.user_interrupt.user_interrupt_agent import UserInterruptAgent
+
 # Other backend imports
 from control_backend.api.v1.router import api_router
 from control_backend.core.config import settings
@@ -138,6 +141,12 @@ async def lifespan(app: FastAPI):
                 "name": settings.agent_settings.bdi_program_manager_name,
             },
         ),
+        "UserInterruptAgent": (
+            UserInterruptAgent,
+            {
+                "name": settings.agent_settings.user_interrupt_name,
+            },
+        ),
     }
 
     agents = []

src/control_backend/schemas/events.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class ButtonPressedEvent(BaseModel):
+    type: str
+    context: str

src/control_backend/schemas/ri_message.py

@@ -38,6 +38,7 @@ class SpeechCommand(RIMessage):
 
     endpoint: RIEndpoint = RIEndpoint(RIEndpoint.SPEECH)
     data: str
+    is_priority: bool = False
 
 
 class GestureCommand(RIMessage):
@@ -52,6 +53,7 @@ class GestureCommand(RIMessage):
         RIEndpoint.GESTURE_SINGLE, RIEndpoint.GESTURE_TAG
     ]
     data: str
+    is_priority: bool = False
 
     @model_validator(mode="after")
     def check_endpoint(self):

test/integration/agents/perception/vad_agent/test_vad_agent.py

@@ -91,7 +91,7 @@ def test_out_socket_creation(zmq_context):
     assert per_vad_agent.audio_out_socket is not None
 
     zmq_context.return_value.socket.assert_called_once_with(zmq.PUB)
-    zmq_context.return_value.socket.return_value.bind_to_random_port.assert_called_once()
+    zmq_context.return_value.socket.return_value.bind.assert_called_once_with("inproc://vad_stream")
 
 
 @pytest.mark.asyncio

test/unit/agents/actuation/test_robot_gesture_agent.py

@@ -73,7 +73,7 @@ async def test_setup_connect(zmq_context, mocker):
 async def test_handle_message_sends_valid_gesture_command():
     """Internal message with valid gesture tag is forwarded to robot pub socket."""
     pubsocket = AsyncMock()
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.pubsocket = pubsocket
 
     payload = {
@@ -91,7 +91,7 @@ async def test_handle_message_sends_valid_gesture_command():
 async def test_handle_message_sends_non_gesture_command():
     """Internal message with non-gesture endpoint is not forwarded by this agent."""
     pubsocket = AsyncMock()
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.pubsocket = pubsocket
 
     payload = {"endpoint": "some_other_endpoint", "data": "invalid_tag_not_in_list"}
@@ -107,7 +107,7 @@ async def test_handle_message_sends_non_gesture_command():
 async def test_handle_message_rejects_invalid_gesture_tag():
     """Internal message with invalid gesture tag is not forwarded."""
     pubsocket = AsyncMock()
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.pubsocket = pubsocket
 
     # Use a tag that's not in gesture_data
@@ -123,7 +123,7 @@ async def test_handle_message_rejects_invalid_gesture_tag():
 async def test_handle_message_invalid_payload():
     """Invalid payload is caught and does not send."""
     pubsocket = AsyncMock()
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.pubsocket = pubsocket
 
     msg = InternalMessage(to="robot", sender="tester", body=json.dumps({"bad": "data"}))
@@ -142,12 +142,12 @@ async def test_zmq_command_loop_valid_gesture_payload():
     async def recv_once():
         # stop after first iteration
         agent._running = False
-        return (b"command", json.dumps(command).encode("utf-8"))
+        return b"command", json.dumps(command).encode("utf-8")
 
     fake_socket.recv_multipart = recv_once
     fake_socket.send_json = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
     agent._running = True
@@ -165,12 +165,12 @@ async def test_zmq_command_loop_valid_non_gesture_payload():
 
     async def recv_once():
         agent._running = False
-        return (b"command", json.dumps(command).encode("utf-8"))
+        return b"command", json.dumps(command).encode("utf-8")
 
     fake_socket.recv_multipart = recv_once
     fake_socket.send_json = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
     agent._running = True
@@ -188,12 +188,12 @@ async def test_zmq_command_loop_invalid_gesture_tag():
 
     async def recv_once():
         agent._running = False
-        return (b"command", json.dumps(command).encode("utf-8"))
+        return b"command", json.dumps(command).encode("utf-8")
 
     fake_socket.recv_multipart = recv_once
     fake_socket.send_json = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
     agent._running = True
@@ -210,12 +210,12 @@ async def test_zmq_command_loop_invalid_json():
 
     async def recv_once():
         agent._running = False
-        return (b"command", b"{not_json}")
+        return b"command", b"{not_json}"
 
     fake_socket.recv_multipart = recv_once
     fake_socket.send_json = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
     agent._running = True
@@ -232,12 +232,12 @@ async def test_zmq_command_loop_ignores_send_gestures_topic():
 
     async def recv_once():
         agent._running = False
-        return (b"send_gestures", b"{}")
+        return b"send_gestures", b"{}"
 
     fake_socket.recv_multipart = recv_once
     fake_socket.send_json = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.subsocket = fake_socket
     agent.pubsocket = fake_socket
     agent._running = True
@@ -259,7 +259,9 @@ async def test_fetch_gestures_loop_without_amount():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"])
+    agent = RobotGestureAgent(
+        "robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"], address=""
+    )
     agent.repsocket = fake_repsocket
     agent._running = True
 
@@ -287,7 +289,9 @@ async def test_fetch_gestures_loop_with_amount():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"])
+    agent = RobotGestureAgent(
+        "robot_gesture", gesture_data=["hello", "yes", "no", "wave", "point"], address=""
+    )
     agent.repsocket = fake_repsocket
     agent._running = True
 
@@ -315,7 +319,7 @@ async def test_fetch_gestures_loop_with_integer_request():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.repsocket = fake_repsocket
     agent._running = True
 
@@ -340,7 +344,7 @@ async def test_fetch_gestures_loop_with_invalid_json():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.repsocket = fake_repsocket
     agent._running = True
 
@@ -365,7 +369,7 @@ async def test_fetch_gestures_loop_with_non_integer_json():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.repsocket = fake_repsocket
     agent._running = True
 
@@ -381,7 +385,7 @@ async def test_fetch_gestures_loop_with_non_integer_json():
 def test_gesture_data_attribute():
     """Test that gesture_data returns the expected list."""
     gesture_data = ["hello", "yes", "no", "wave"]
-    agent = RobotGestureAgent("robot_gesture", gesture_data=gesture_data)
+    agent = RobotGestureAgent("robot_gesture", gesture_data=gesture_data, address="")
 
     assert agent.gesture_data == gesture_data
     assert isinstance(agent.gesture_data, list)
@@ -398,7 +402,7 @@ async def test_stop_closes_sockets():
     pubsocket = MagicMock()
     subsocket = MagicMock()
     repsocket = MagicMock()
-    agent = RobotGestureAgent("robot_gesture")
+    agent = RobotGestureAgent("robot_gesture", address="")
     agent.pubsocket = pubsocket
     agent.subsocket = subsocket
     agent.repsocket = repsocket
@@ -415,7 +419,7 @@ async def test_stop_closes_sockets():
 async def test_initialization_with_custom_gesture_data():
     """Agent can be initialized with custom gesture data."""
     custom_gestures = ["custom1", "custom2", "custom3"]
-    agent = RobotGestureAgent("robot_gesture", gesture_data=custom_gestures)
+    agent = RobotGestureAgent("robot_gesture", gesture_data=custom_gestures, address="")
 
     assert agent.gesture_data == custom_gestures
 
@@ -432,7 +436,7 @@ async def test_fetch_gestures_loop_handles_exception():
     fake_repsocket.recv = recv_once
     fake_repsocket.send = AsyncMock()
 
-    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"])
+    agent = RobotGestureAgent("robot_gesture", gesture_data=["hello", "yes", "no"], address="")
     agent.repsocket = fake_repsocket
     agent.logger = MagicMock()
     agent._running = True

test/unit/agents/actuation/test_robot_speech_agent.py

@@ -64,7 +64,7 @@ async def test_handle_message_sends_command():
     agent = mock_speech_agent()
     agent.pubsocket = pubsocket
 
-    payload = {"endpoint": "actuate/speech", "data": "hello"}
+    payload = {"endpoint": "actuate/speech", "data": "hello", "is_priority": False}
     msg = InternalMessage(to="robot", sender="tester", body=json.dumps(payload))
 
     await agent.handle_message(msg)
@@ -75,7 +75,7 @@ async def test_handle_message_sends_command():
 @pytest.mark.asyncio
 async def test_zmq_command_loop_valid_payload(zmq_context):
     """UI command is read from SUB and published."""
-    command = {"endpoint": "actuate/speech", "data": "hello"}
+    command = {"endpoint": "actuate/speech", "data": "hello", "is_priority": False}
     fake_socket = AsyncMock()
 
     async def recv_once():

test/unit/agents/bdi/test_bdi_program_manager.py

@@ -63,6 +63,7 @@ async def test_receive_programs_valid_and_invalid():
     manager = BDIProgramManager(name="program_manager_test")
     manager.sub_socket = sub
     manager._send_to_bdi = AsyncMock()
+    manager._send_clear_llm_history = AsyncMock()
 
     try:
         # Will give StopAsyncIteration when the predefined `sub.recv_multipart` side-effects run out
@@ -75,3 +76,24 @@ async def test_receive_programs_valid_and_invalid():
     forwarded: Program = manager._send_to_bdi.await_args[0][0]
     assert forwarded.phases[0].norms[0].norm == "N1"
     assert forwarded.phases[0].goals[0].description == "G1"
+
+    # Verify history clear was triggered
+    assert manager._send_clear_llm_history.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_send_clear_llm_history(mock_settings):
+    # Ensure the mock returns a string for the agent name (just like in your LLM tests)
+    mock_settings.agent_settings.llm_agent_name = "llm_agent"
+
+    manager = BDIProgramManager(name="program_manager_test")
+    manager.send = AsyncMock()
+
+    await manager._send_clear_llm_history()
+
+    assert manager.send.await_count == 1
+    msg: InternalMessage = manager.send.await_args[0][0]
+
+    # Verify the content and recipient
+    assert msg.body == "clear_history"
+    assert msg.to == "llm_agent"

test/unit/agents/communication/test_ri_communication_agent.py

@@ -67,6 +67,7 @@ async def test_setup_success_connects_and_starts_robot(zmq_context):
         address="tcp://localhost:5556",
         bind=False,
         gesture_data=[],
+        single_gesture_data=[],
     )
     agent.add_behavior.assert_called_once()
 

test/unit/agents/llm/test_llm_agent.py

@@ -197,6 +197,9 @@ async def test_query_llm_yields_final_tail_chunk(mock_settings):
     agent = LLMAgent("llm_agent")
     agent.send = AsyncMock()
 
+    agent.logger = MagicMock()
+    agent.logger.llm = MagicMock()
+
     # Patch _stream_query_llm to yield tokens that do NOT end with punctuation
     async def fake_stream(messages):
         yield "Hello"
@@ -262,3 +265,23 @@ async def test_stream_query_llm_skips_non_data_lines(mock_httpx_client, mock_set
 
     # Only the valid 'data:' line should yield content
     assert tokens == ["Hi"]
+
+
+@pytest.mark.asyncio
+async def test_clear_history_command(mock_settings):
+    """Test that the 'clear_history' message clears the agent's memory."""
+    # setup LLM to have some history
+    mock_settings.agent_settings.bdi_program_manager_name = "bdi_program_manager_agent"
+    agent = LLMAgent("llm_agent")
+    agent.history = [
+        {"role": "user", "content": "Old conversation context"},
+        {"role": "assistant", "content": "Old response"},
+    ]
+    assert len(agent.history) == 2
+    msg = InternalMessage(
+        to="llm_agent",
+        sender=mock_settings.agent_settings.bdi_program_manager_name,
+        body="clear_history",
+    )
+    await agent.handle_message(msg)
+    assert len(agent.history) == 0

test/unit/agents/perception/vad_agent/test_vad_streaming.py

@@ -7,6 +7,15 @@ import zmq
 from control_backend.agents.perception.vad_agent import VADAgent
 
 
+# We don't want to use real ZMQ in unit tests, for example because it can give errors when sockets
+# aren't closed properly.
+@pytest.fixture(autouse=True)
+def mock_zmq():
+    with patch("zmq.asyncio.Context") as mock:
+        mock.instance.return_value = MagicMock()
+        yield mock
+
+
 @pytest.fixture
 def audio_out_socket():
     return AsyncMock()
@@ -140,12 +149,10 @@ async def test_vad_model_load_failure_stops_agent(vad_agent):
         # Patch stop to an AsyncMock so we can check it was awaited
         vad_agent.stop = AsyncMock()
 
-        result = await vad_agent.setup()
+        await vad_agent.setup()
 
         # Assert stop was called
         vad_agent.stop.assert_awaited_once()
-        # Assert setup returned None
-        assert result is None
 
 
 @pytest.mark.asyncio
@@ -155,7 +162,7 @@ async def test_audio_out_bind_failure_sets_none_and_logs(vad_agent, caplog):
     audio_out_socket is set to None, None is returned, and an error is logged.
     """
     mock_socket = MagicMock()
-    mock_socket.bind_to_random_port.side_effect = zmq.ZMQBindError()
+    mock_socket.bind.side_effect = zmq.ZMQBindError()
     with patch("control_backend.agents.perception.vad_agent.azmq.Context.instance") as mock_ctx:
         mock_ctx.return_value.socket.return_value = mock_socket
 

test/unit/agents/user_interrupt/test_user_interrupt.py

@@ -0,0 +1,146 @@
+import asyncio
+import json
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from control_backend.agents.user_interrupt.user_interrupt_agent import UserInterruptAgent
+from control_backend.core.agent_system import InternalMessage
+from control_backend.core.config import settings
+from control_backend.schemas.ri_message import RIEndpoint
+
+
+@pytest.fixture
+def agent():
+    agent = UserInterruptAgent(name="user_interrupt_agent")
+    agent.send = AsyncMock()
+    agent.logger = MagicMock()
+    agent.sub_socket = AsyncMock()
+    return agent
+
+
+@pytest.mark.asyncio
+async def test_send_to_speech_agent(agent):
+    """Verify speech command format."""
+    await agent._send_to_speech_agent("Hello World")
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.robot_speech_name
+    body = json.loads(sent_msg.body)
+    assert body["data"] == "Hello World"
+    assert body["is_priority"] is True
+
+
+@pytest.mark.asyncio
+async def test_send_to_gesture_agent(agent):
+    """Verify gesture command format."""
+    await agent._send_to_gesture_agent("wave_hand")
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.robot_gesture_name
+    body = json.loads(sent_msg.body)
+    assert body["data"] == "wave_hand"
+    assert body["is_priority"] is True
+    assert body["endpoint"] == RIEndpoint.GESTURE_SINGLE.value
+
+
+@pytest.mark.asyncio
+async def test_send_to_program_manager(agent):
+    """Verify belief update format."""
+    context_str = "2"
+
+    await agent._send_to_program_manager(context_str)
+
+    agent.send.assert_awaited_once()
+    sent_msg: InternalMessage = agent.send.call_args.args[0]
+
+    assert sent_msg.to == settings.agent_settings.bdi_program_manager_name
+    assert sent_msg.thread == "belief_override_id"
+
+    body = json.loads(sent_msg.body)
+
+    assert body["belief"] == context_str
+
+
+@pytest.mark.asyncio
+async def test_receive_loop_routing_success(agent):
+    """
+    Test that the loop correctly:
+    1. Receives 'button_pressed' topic from ZMQ
+    2. Parses the JSON payload to find 'type' and 'context'
+    3. Calls the correct handler method based on 'type'
+    """
+    # Prepare JSON payloads as bytes
+    payload_speech = json.dumps({"type": "speech", "context": "Hello Speech"}).encode()
+    payload_gesture = json.dumps({"type": "gesture", "context": "Hello Gesture"}).encode()
+    payload_override = json.dumps({"type": "override", "context": "Hello Override"}).encode()
+
+    agent.sub_socket.recv_multipart.side_effect = [
+        (b"button_pressed", payload_speech),
+        (b"button_pressed", payload_gesture),
+        (b"button_pressed", payload_override),
+        asyncio.CancelledError,  # Stop the infinite loop
+    ]
+
+    agent._send_to_speech_agent = AsyncMock()
+    agent._send_to_gesture_agent = AsyncMock()
+    agent._send_to_program_manager = AsyncMock()
+
+    try:
+        await agent._receive_button_event()
+    except asyncio.CancelledError:
+        pass
+
+    await asyncio.sleep(0)
+
+    # Speech
+    agent._send_to_speech_agent.assert_awaited_once_with("Hello Speech")
+
+    # Gesture
+    agent._send_to_gesture_agent.assert_awaited_once_with("Hello Gesture")
+
+    # Override
+    agent._send_to_program_manager.assert_awaited_once_with("Hello Override")
+
+    assert agent._send_to_speech_agent.await_count == 1
+    assert agent._send_to_gesture_agent.await_count == 1
+    assert agent._send_to_program_manager.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_receive_loop_unknown_type(agent):
+    """Test that unknown 'type' values in the JSON log a warning and do not crash."""
+
+    # Prepare a payload with an unknown type
+    payload_unknown = json.dumps({"type": "unknown_thing", "context": "some_data"}).encode()
+
+    agent.sub_socket.recv_multipart.side_effect = [
+        (b"button_pressed", payload_unknown),
+        asyncio.CancelledError,
+    ]
+
+    agent._send_to_speech_agent = AsyncMock()
+    agent._send_to_gesture_agent = AsyncMock()
+    agent._send_to_belief_collector = AsyncMock()
+
+    try:
+        await agent._receive_button_event()
+    except asyncio.CancelledError:
+        pass
+
+    await asyncio.sleep(0)
+
+    # Ensure no handlers were called
+    agent._send_to_speech_agent.assert_not_called()
+    agent._send_to_gesture_agent.assert_not_called()
+    agent._send_to_belief_collector.assert_not_called()
+
+    agent.logger.warning.assert_called_with(
+        "Received button press with unknown type '%s' (context: '%s').",
+        "unknown_thing",
+        "some_data",
+    )