Merge remote-tracking branch 'origin/dev' into feat/belief-from-text

# Conflicts:
#	src/control_backend/main.py

src/control_backend/agents/bdi/bdi_core.py

@@ -1,35 +1,71 @@
 import logging
 
 import agentspeak
+from spade.behaviour import OneShotBehaviour
+from spade.message import Message
 from spade_bdi.bdi import BDIAgent
 
-from control_backend.agents.bdi.behaviours.belief_setter import BeliefSetter
+from control_backend.agents.bdi.behaviours.belief_setter import BeliefSetterBehaviour
+from control_backend.agents.bdi.behaviours.receive_llm_resp_behaviour import (
+    ReceiveLLMResponseBehaviour,
+)
+from control_backend.core.config import settings
+
 
 class BDICoreAgent(BDIAgent):
     """
-    This is the Brain agent that does the belief inference with AgentSpeak. 
+    This is the Brain agent that does the belief inference with AgentSpeak.
     This is a continous process that happens automatically in the background.
     This class contains all the actions that can be called from AgentSpeak plans.
-    It has the BeliefSetter behaviour.
+    It has the BeliefSetter behaviour and can aks and recieve requests from the LLM agent.
     """
-    logger = logging.getLogger("BDI Core")
 
-    async def setup(self):
-        belief_setter = BeliefSetter()
-        self.add_behaviour(belief_setter)
+    logger = logging.getLogger("bdi_core_agent")
+
+    async def setup(self) -> None:
+        """
+        Initializes belief behaviors and message routing.
+        """
+        self.logger.info("BDICoreAgent setup started")
+
+        self.add_behaviour(BeliefSetterBehaviour())
+        self.add_behaviour(ReceiveLLMResponseBehaviour())
+
+        await self._send_to_llm("Hi pepper, how are you?")
+        # This is the example message currently sent to the llm at the start of the Program
+
+        self.logger.info("BDICoreAgent setup complete")
+
+    def add_custom_actions(self, actions) -> None:
+        """
+        Registers custom AgentSpeak actions callable from plans.
+        """
 
-    def add_custom_actions(self, actions):
         @actions.add(".reply", 1)
-        def _reply(agent, term, intention):
-            message = agentspeak.grounded(term.args[0], intention.scope)
-            self.logger.info(f"Replying to message: {message}")
-            reply = self._send_to_llm(message)
-            self.logger.info(f"Received reply: {reply}")
+        def _reply(agent: "BDICoreAgent", term, intention):
+            """
+            Sends text to the LLM (AgentSpeak action).
+            Example: .reply("Hello LLM!")
+            """
+            message_text = agentspeak.grounded(term.args[0], intention.scope)
+            self.logger.info("Reply action sending: %s", message_text)
 
+            self._send_to_llm(message_text)
             yield
 
-    def _send_to_llm(self, message) -> str:
-        """TODO: implement"""
-        return f"This is a reply to {message}"
+    async def _send_to_llm(self, text: str):
+        """
+        Sends a text query to the LLM Agent asynchronously.
+        """
 
+        class SendBehaviour(OneShotBehaviour):
+            async def run(self) -> None:
+                msg = Message(
+                    to= settings.agent_settings.llm_agent_name + '@' + settings.agent_settings.host,
+                    body= text
+                )
 
+                await self.send(msg)
+                self.agent.logger.debug("Message sent to LLM: %s", text)
+
+        self.add_behaviour(SendBehaviour())

src/control_backend/agents/bdi/behaviours/belief_setter.py

@@ -1,28 +1,28 @@
-import asyncio
 import json
 import logging
 
 from spade.agent import Message
 from spade.behaviour import CyclicBehaviour
-from spade_bdi.bdi import BDIAgent
+from spade_bdi.bdi import BDIAgent, BeliefNotInitiated
 
 from control_backend.core.config import settings
 
-class BeliefSetter(CyclicBehaviour):
+
+class BeliefSetterBehaviour(CyclicBehaviour):
     """
-    This is the behaviour that the BDI agent runs.
-    This behaviour waits for incoming message and processes it based on sender.
-    Currently, t only waits for messages containing beliefs from Belief Collector and adds these to its KB.
+    This is the behaviour that the BDI agent runs. This behaviour waits for incoming
+    message and processes it based on sender.
     """
+
     agent: BDIAgent
     logger = logging.getLogger("BDI/Belief Setter")
-    
+
     async def run(self):
         msg = await self.receive(timeout=0.1)
         if msg:
             self.logger.info(f"Received message {msg.body}")
             self._process_message(msg)
-        await asyncio.sleep(1)
+
 
     def _process_message(self, message: Message):
         sender = message.sender.node  # removes host from jid and converts to str
@@ -33,28 +33,38 @@ class BeliefSetter(CyclicBehaviour):
                 self.logger.debug("Processing message from belief collector.")
                 self._process_belief_message(message)
             case _:
+                self.logger.debug("Not the belief agent, discarding message")
                 pass
 
     def _process_belief_message(self, message: Message):
-        if not message.body: return
+        if not message.body:
+            return
 
         match message.thread:
             case "beliefs":
                 try:
-                    beliefs: dict[str, list[list[str]]] = json.loads(message.body)
+                    beliefs: dict[str, list[str]] = json.loads(message.body)
                     self._set_beliefs(beliefs)
                 except json.JSONDecodeError as e:
                     self.logger.error("Could not decode beliefs into JSON format: %s", e)
             case _:
                 pass
 
-
-    def _set_beliefs(self, beliefs: dict[str, list[list[str]]]):
+    def _set_beliefs(self, beliefs: dict[str, list[str]]):
+        """Remove previous values for beliefs and update them with the provided values."""
         if self.agent.bdi is None:
             self.logger.warning("Cannot set beliefs, since agent's BDI is not yet initialized.")
             return
 
-        for belief, arguments_list in beliefs.items():
-            for arguments in arguments_list:
-                self.agent.bdi.set_belief(belief, *arguments)
-                self.logger.info("Set belief %s with arguments %s", belief, arguments)
+        # Set new beliefs (outdated beliefs are automatically removed)
+        for belief, arguments in beliefs.items():
+            self.agent.bdi.set_belief(belief, *arguments)
+
+            # Special case: if there's a new user message, flag that we haven't responded yet
+            if belief == "user_said":
+                try:
+                    self.agent.bdi.remove_belief("responded")
+                except BeliefNotInitiated:
+                    pass
+
+            self.logger.info("Set belief %s with arguments %s", belief, arguments)

src/control_backend/agents/bdi/behaviours/receive_llm_resp_behaviour.py

@@ -0,0 +1,26 @@
+import logging
+
+from spade.behaviour import CyclicBehaviour
+
+from control_backend.core.config import settings
+
+
+class ReceiveLLMResponseBehaviour(CyclicBehaviour):
+    """
+    Adds behavior to receive responses from the LLM Agent.
+    """
+    logger = logging.getLogger("BDI/LLM Reciever")
+    async def run(self):
+        msg = await self.receive(timeout=2)
+        if not msg:
+            return
+
+        sender = msg.sender.node 
+        match sender:
+            case settings.agent_settings.llm_agent_name:
+                content = msg.body
+                self.logger.info("Received LLM response: %s", content)
+                #Here the BDI can pass the message back as a response
+            case _:
+                self.logger.debug("Not from the llm, discarding message")
+                pass