feat: add BDI core agent

Main BDI brain structure implemented. Still some TODOs left, and very
basic implementation (only one belief "user_said(Message)" and every
message is sent straight to a function which is responsible for getting
an LLM response.

ref: N25B-197

src/control_backend/agents/bdi/bdi_core.py

@@ -0,0 +1,32 @@
+import logging
+
+import agentspeak
+from spade_bdi.bdi import BDIAgent
+
+from control_backend.agents.bdi.behaviours.belief_setter import BeliefSetter
+
+class BDICore(BDIAgent):
+    """
+    TODO: docs
+    """
+    logger = logging.getLogger("BDI Core")
+
+    async def setup(self):
+        belief_setter = BeliefSetter()
+        self.add_behaviour(belief_setter)
+
+    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}")
+
+            yield
+
+    def _send_to_llm(self, message) -> str:
+        """TODO: implement"""
+        return f"This is a reply to {message}"
+
+

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

@@ -0,0 +1,57 @@
+import asyncio
+import json
+import logging
+
+from spade.agent import Message
+from spade.behaviour import CyclicBehaviour
+from spade_bdi.bdi import BDIAgent
+
+from control_backend.core.config import settings
+
+class BeliefSetter(CyclicBehaviour):
+    """
+    TODO: docs
+    """
+    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
+        self.logger.debug("Sender: %s", sender)
+
+        match sender:
+            case settings.agent_settings.belief_collector_agent_name:
+                self.logger.debug("Processing message from belief collector.")
+                self._process_belief_message(message)
+            case _:
+                pass
+
+    def _process_belief_message(self, message: Message):
+        if not message.body: return
+
+        match message.thread:
+            case "beliefs":
+                try:
+                    beliefs: dict[str, list[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]]]):
+        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)

src/control_backend/agents/bdi/rules.asl

@@ -0,0 +1,3 @@
++user_said(Message) : not responded <-
+  +responded;
+  .reply(Message).

src/control_backend/core/config.py

@@ -1,15 +1,24 @@
+from re import L
 from pydantic import BaseModel
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 class ZMQSettings(BaseModel):
     internal_comm_address: str = "tcp://localhost:5560"
 
+class AgentSettings(BaseModel):
+    host: str = "localhost"
+    bdi_core_agent_name: str = "bdi_core"
+    belief_collector_agent_name: str = "belief_collector"
+    test_agent_name: str = "test_agent"
+
 class Settings(BaseSettings):
     app_title: str = "PepperPlus"
-    
+
     ui_url: str = "http://localhost:5173"
 
     zmq_settings: ZMQSettings = ZMQSettings()
+
+    agent_settings: AgentSettings = AgentSettings()
     
     model_config = SettingsConfigDict(env_file=".env")
     

src/control_backend/main.py

@@ -1,18 +1,24 @@
+# Standard library imports
+import asyncio
+import json
+
 # External imports
 import contextlib
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 import logging
+from spade.agent import Agent, Message
+from spade.behaviour import OneShotBehaviour
 import zmq
 
 # Internal imports
-from control_backend.agents.test_agent import TestAgent
+from control_backend.agents.bdi.bdi_core import BDICore
 from control_backend.api.v1.router import api_router
-from control_backend.core.config import settings
+from control_backend.core.config import AgentSettings, settings
 from control_backend.core.zmq_context import context
 
 logger = logging.getLogger(__name__)
-logging.basicConfig(level=logging.INFO)
+logging.basicConfig(level=logging.DEBUG)
 
 @contextlib.asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -26,13 +32,23 @@ async def lifespan(app: FastAPI):
     logger.info("Internal publishing socket bound to %s", internal_comm_socket)
 
     # Initiate agents
-    test_agent = TestAgent("test_agent@localhost", "test_agent")
-    await test_agent.start()
+    bdi_core = BDICore(settings.agent_settings.bdi_core_agent_name + '@' + settings.agent_settings.host, settings.agent_settings.bdi_core_agent_name, "src/control_backend/agents/bdi/rules.asl")
+    await bdi_core.start()
     
+    # -----------TEMORARY SECTION-------------
+    belief_collector = Agent(settings.agent_settings.belief_collector_agent_name + '@' + settings.agent_settings.host, settings.agent_settings.belief_collector_agent_name)
+    await belief_collector.start()
+
+    class SendMessageBehaviour(OneShotBehaviour):
+        async def run(self):
+            await self.send(Message(bdi_core.jid, belief_collector.jid, json.dumps({"user_said": [["Hello World!"]]}), "beliefs"))
+
+    belief_collector.add_behaviour(SendMessageBehaviour())
+    # -----------TEMORARY SECTION-------------
+   
     yield
     
     logger.info("%s shutting down.", app.title)
-    
 
 # if __name__ == "__main__":
 app = FastAPI(title=settings.app_title, lifespan=lifespan)