mhagenta 1.0.0__tar.gz

mhagenta-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Dmitry Gnatyshak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the Software), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, andor sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mhagenta-1.0.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.1
+Name: mhagenta
+Version: 1.0.0
+Summary: MHAgentA allows you to design and run simulations with containerized Modular Hybrid Agents.
+Author: Dmitry Gnatyshak
+Author-email: dmitry.gnatyshak@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: dill (>=0.3.9,<0.4.0)
+Requires-Dist: docker (>=7.1.0,<8.0.0)
+Requires-Dist: pika (>=1.3.2,<2.0.0)
+Requires-Dist: pika-stubs (>=0.1.3,<0.2.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Description-Content-Type: text/markdown
+
+# MHAgentA
+
+**MHAgentA** (Modular Hybrid Agent Architecture) is a framework for developing container-based agents with complex
+behaviors. Each agent is composed of a number of semi-autonomous modules, each focusing on their own tasks (either 
+reactively or proactively) and communicating with each other.
+
+The framework handles all the internal workings of each agent automatically, but leaves the exact implementations of 
+their modules' behaviors up to the user. This way agents of varying levels of complexity can be developed, from simple
+reactive ones, to sophisticated deliberative (or hybrid) ones. 
+
+## Installation
+
+You can install MHAgentA with pip:
+
+```
+pip install mhagenta
+```
+
+## High-level Model
+
+Full high-level model of MHAgentA modules and their interaction scheme is shown below. An agent can have instances of
+each of them (including multiple instances of modules of the same type) or just a subset. Note that it is not necessary 
+to use all of these module types, as simplest behaviors can be implemented even with just one of them.
+
+![](https://raw.githubusercontent.com/Auron-tliar/mhagenta/957ec749d5fba20b21b2ab1e353481aed530ea58/docs/images/MHAgentA_modules.png)
+
+There are 8 types of agent modules, defined by their role in the agent's internal communication scheme. Each module is
+run as a separate process communicating with others as necessary. Each of them can be purely reactive, or can have
+additional periodic internal computations. Essentially, one can view each agent's module as an agent in itw own right,
+and a MHAgentA agent – as a closed multi-agent system with strongly defined communication scheme.
+
+1. **Low-level reasoner**. Handles basic fast decision-making and reactions to the environment.
+2. **Perceptor**. Observes the agent's environment.
+3. **Actuator**. Acts upon the environment.
+4. **Knowledge model**. Contains and processes inherent and acquired knowledge of the agent and/or the world model.
+5. **High-level reasoner**. Strategizes and comes up with long-term plans.
+6. **Goal graph**. Represents agent's plan structure and handles its updates.
+7. **Memory**. Stores, processes, and allows access to old observation data and outdated knowledge.
+8. **Learner**. Handles (machine learning-based) training of models used by the reasoners.
+
+When interacting with each other, each model can either request or send some data as per the communication scheme above.
+
+## Agent Implementation and Execution
+
+To define an agent, you need to define all the relevant modules. You can to that by extending base classes for them from
+the `mhagenta.bases` submodule. Each of these base classes have the nameplate functions related to the module's periodic
+step function, utility functions, and reaction to messages from other modules functions. Override their default (empty) 
+implementations to define a desired behavior.
+
+The functions to override are:
+
+- `step(state: State) -> State` – is called in set intervals as defined by the `step_frequency` parameter when defining 
+an agent;
+- `on_init(**kwargs) -> None` – is called when the module has finished initializing, before the agent execution start 
+is scheduled. Use it if your custom module needs additional setup steps;
+- `on_first(state: State) -> State` – is called right after the execution start before the first call to the `step`
+function
+- `on_last(state: State) -> State` – is called when the stop signal is received (or when the timeout is reached), right 
+before the module execution stops;
+- `on_<message_type>(state: State, ...) -> State` – is called when a message of a predefined type received.
+
+Each module base has its own set of nameplates for the message reactions that you can override. Additionally, when 
+overriding these functions, it is recommended to use module specific State classes from `mhagenta.states` as type hints,
+such as `PerceptorState` or `LLState` instead of the default one, as they will provide hints for outboxes (see below).   
+
+All the functions executed during the agent execution have State as their first argument. States contain user defined
+fields (you can specify them during the module initialization), additional useful information, such as module ID, time 
+since the start of the agent execution, a directory of all other module IDs organized by module types, and the `outbox` 
+object. The latter is used to send out messages to other modules. If module-specific state class is used, it will 
+display the functions for sending all the established message types to their designated recipients. For instance, to 
+send a set of beliefs from a low-level reasoner to a knowledge module, you type:
+
+```python
+state.outbox.send_beliefs(knowledge_id='knowledge_module_id', beliefs=[...], ...)
+```
+
+Be sure to return the modified state at the end of the function, and all the outgoing messages will get processed 
+automatically.
+
+After defining all the necessary module classes, you need an `Orchestrator` (available from module's root) object to 
+handle the creation and execution of the agents. When creating an orchestrator you can also redefine default values of
+agent parameters if different agents share them a lot. Full signature of the Orchestrator's init function is 
+provided in the MHAgentA's API documentation.
+
+Use `Orchestrator.add_agent(...)` then to compose an agent. To it you need to pass on instances of the relevant modules 
+and various parameters, such as agent's ID, frequencies of periodic functions, number of copies of this agent to run, 
+whether to resume execution with previously saved stated, etc.
+
+Note that when instantiating modules, you need to define a unique ID for the module, any keyword arguments for its 
+`on_init` function (if any), and initial fields and their value for the module's state as a `dict[str, Any]`. These
+fields will be added to the state's field dictionary and so that they can be accessed at the runtime with 
+`state.field_name`.
+
+When done, you can run all the agents togather with
+
+```python
+orchestrator.run()
+```
+
+The internal run function is asynchronous. If you want to hande its execution yourself (i.e. add it to another task 
+group), you can use `orchestrator.arun()` instead.
+

mhagenta-1.0.0/README.md

@@ -0,0 +1,101 @@
+# MHAgentA
+
+**MHAgentA** (Modular Hybrid Agent Architecture) is a framework for developing container-based agents with complex
+behaviors. Each agent is composed of a number of semi-autonomous modules, each focusing on their own tasks (either 
+reactively or proactively) and communicating with each other.
+
+The framework handles all the internal workings of each agent automatically, but leaves the exact implementations of 
+their modules' behaviors up to the user. This way agents of varying levels of complexity can be developed, from simple
+reactive ones, to sophisticated deliberative (or hybrid) ones. 
+
+## Installation
+
+You can install MHAgentA with pip:
+
+```
+pip install mhagenta
+```
+
+## High-level Model
+
+Full high-level model of MHAgentA modules and their interaction scheme is shown below. An agent can have instances of
+each of them (including multiple instances of modules of the same type) or just a subset. Note that it is not necessary 
+to use all of these module types, as simplest behaviors can be implemented even with just one of them.
+
+![](https://raw.githubusercontent.com/Auron-tliar/mhagenta/957ec749d5fba20b21b2ab1e353481aed530ea58/docs/images/MHAgentA_modules.png)
+
+There are 8 types of agent modules, defined by their role in the agent's internal communication scheme. Each module is
+run as a separate process communicating with others as necessary. Each of them can be purely reactive, or can have
+additional periodic internal computations. Essentially, one can view each agent's module as an agent in itw own right,
+and a MHAgentA agent – as a closed multi-agent system with strongly defined communication scheme.
+
+1. **Low-level reasoner**. Handles basic fast decision-making and reactions to the environment.
+2. **Perceptor**. Observes the agent's environment.
+3. **Actuator**. Acts upon the environment.
+4. **Knowledge model**. Contains and processes inherent and acquired knowledge of the agent and/or the world model.
+5. **High-level reasoner**. Strategizes and comes up with long-term plans.
+6. **Goal graph**. Represents agent's plan structure and handles its updates.
+7. **Memory**. Stores, processes, and allows access to old observation data and outdated knowledge.
+8. **Learner**. Handles (machine learning-based) training of models used by the reasoners.
+
+When interacting with each other, each model can either request or send some data as per the communication scheme above.
+
+## Agent Implementation and Execution
+
+To define an agent, you need to define all the relevant modules. You can to that by extending base classes for them from
+the `mhagenta.bases` submodule. Each of these base classes have the nameplate functions related to the module's periodic
+step function, utility functions, and reaction to messages from other modules functions. Override their default (empty) 
+implementations to define a desired behavior.
+
+The functions to override are:
+
+- `step(state: State) -> State` – is called in set intervals as defined by the `step_frequency` parameter when defining 
+an agent;
+- `on_init(**kwargs) -> None` – is called when the module has finished initializing, before the agent execution start 
+is scheduled. Use it if your custom module needs additional setup steps;
+- `on_first(state: State) -> State` – is called right after the execution start before the first call to the `step`
+function
+- `on_last(state: State) -> State` – is called when the stop signal is received (or when the timeout is reached), right 
+before the module execution stops;
+- `on_<message_type>(state: State, ...) -> State` – is called when a message of a predefined type received.
+
+Each module base has its own set of nameplates for the message reactions that you can override. Additionally, when 
+overriding these functions, it is recommended to use module specific State classes from `mhagenta.states` as type hints,
+such as `PerceptorState` or `LLState` instead of the default one, as they will provide hints for outboxes (see below).   
+
+All the functions executed during the agent execution have State as their first argument. States contain user defined
+fields (you can specify them during the module initialization), additional useful information, such as module ID, time 
+since the start of the agent execution, a directory of all other module IDs organized by module types, and the `outbox` 
+object. The latter is used to send out messages to other modules. If module-specific state class is used, it will 
+display the functions for sending all the established message types to their designated recipients. For instance, to 
+send a set of beliefs from a low-level reasoner to a knowledge module, you type:
+
+```python
+state.outbox.send_beliefs(knowledge_id='knowledge_module_id', beliefs=[...], ...)
+```
+
+Be sure to return the modified state at the end of the function, and all the outgoing messages will get processed 
+automatically.
+
+After defining all the necessary module classes, you need an `Orchestrator` (available from module's root) object to 
+handle the creation and execution of the agents. When creating an orchestrator you can also redefine default values of
+agent parameters if different agents share them a lot. Full signature of the Orchestrator's init function is 
+provided in the MHAgentA's API documentation.
+
+Use `Orchestrator.add_agent(...)` then to compose an agent. To it you need to pass on instances of the relevant modules 
+and various parameters, such as agent's ID, frequencies of periodic functions, number of copies of this agent to run, 
+whether to resume execution with previously saved stated, etc.
+
+Note that when instantiating modules, you need to define a unique ID for the module, any keyword arguments for its 
+`on_init` function (if any), and initial fields and their value for the module's state as a `dict[str, Any]`. These
+fields will be added to the state's field dictionary and so that they can be accessed at the runtime with 
+`state.field_name`.
+
+When done, you can run all the agents togather with
+
+```python
+orchestrator.run()
+```
+
+The internal run function is asynchronous. If you want to hande its execution yourself (i.e. add it to another task 
+group), you can use `orchestrator.arun()` instead.

mhagenta-1.0.0/mhagenta/__init__.py

@@ -0,0 +1,6 @@
+from mhagenta.core import Orchestrator
+from mhagenta.utils import State, Directory, Observation, Goal, Belief, ActionStatus
+from mhagenta import bases, outboxes
+
+
+__all__ = ['Orchestrator', 'State', 'Directory', 'Observation', 'Goal', 'Belief', 'ActionStatus', 'bases', 'outboxes']

mhagenta-1.0.0/mhagenta/bases/__init__.py

@@ -0,0 +1,10 @@
+from mhagenta.core.processes import ModuleBase
+from mhagenta.modules.perception import PerceptorBase
+from mhagenta.modules.actuation import ActuatorBase
+from mhagenta.modules.low_level import LLReasonerBase, LearnerBase
+from mhagenta.modules.high_level import KnowledgeBase, HLReasonerBase, GoalGraphBase
+from mhagenta.modules.memory import MemoryBase
+
+
+__all__ = ['ModuleBase', 'PerceptorBase', 'ActuatorBase', 'LLReasonerBase', 'LearnerBase', 'KnowledgeBase', 'HLReasonerBase',
+           'GoalGraphBase', 'MemoryBase']

mhagenta-1.0.0/mhagenta/containers/CONTAINER_VERSION.py

@@ -0,0 +1 @@
+CONTAINER_VERSION = '1.0.0'

mhagenta-1.0.0/mhagenta/containers/__init__.py

@@ -0,0 +1,10 @@
+from pathlib import Path
+from .CONTAINER_VERSION import CONTAINER_VERSION
+
+
+RABBIT_IMG_PATH = str((Path(__file__).parent / 'mha-rabbitmq/').absolute())
+BASE_IMG_PATH = str((Path(__file__).parent / 'mha-base/').absolute())
+AGENT_IMG_PATH = str((Path(__file__).parent / 'mha-main/').absolute())
+
+
+__all__ = ['RABBIT_IMG_PATH', 'BASE_IMG_PATH', 'AGENT_IMG_PATH', 'CONTAINER_VERSION']

mhagenta-1.0.0/mhagenta/containers/mha-base/Dockerfile

@@ -0,0 +1,10 @@
+ARG SRC_IMAGE="mha-rabbitmq"
+ARG SRC_VERSION="latest"
+FROM ${SRC_IMAGE}:${SRC_VERSION}
+LABEL authors="Dmitry Gnatyshak"
+
+COPY ./mhagenta/ /src/mhagenta/
+COPY ./mhagenta/scripts/pyproject.toml /src/pyproject.toml
+COPY ./mhagenta/scripts/README.md /src/README.md
+
+RUN python -m pip install -e /src/

mhagenta-1.0.0/mhagenta/containers/mha-main/Dockerfile

@@ -0,0 +1,14 @@
+ARG SRC_IMAGE="mha-base"
+ARG SRC_VERSION="latest"
+FROM ${SRC_IMAGE}:${SRC_VERSION}
+LABEL authors="Dmitry Gnatyshak"
+
+COPY src /agent/
+RUN mkdir -p /out/logs
+RUN mkdir -p /out/save
+
+RUN rabbitmq-server -detached
+RUN sleep 5
+
+ENTRYPOINT ["sh"]
+CMD ["/agent/start.sh"]

mhagenta-1.0.0/mhagenta/containers/mha-rabbitmq/Dockerfile

@@ -0,0 +1,5 @@
+FROM python:3.12
+LABEL authors="Dmitry Gnatyshak"
+
+COPY rabbitmq-install.sh /src/
+RUN sh /src/rabbitmq-install.sh

mhagenta-1.0.0/mhagenta/containers/mha-rabbitmq/rabbitmq-install.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+
+apt-get install curl gnupg apt-transport-https -y
+
+## Team RabbitMQ's main signing key
+curl -1sLf "https://keys.openpgp.org/vks/v1/by-fingerprint/0A9AF2115F4687BD29803A206B73A36E6026DFCA" | gpg --dearmor | tee /usr/share/keyrings/com.rabbitmq.team.gpg > /dev/null
+## Community mirror of Cloudsmith: modern Erlang repository
+curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-erlang.E495BB49CC4BBE5B.key | gpg --dearmor | tee /usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg > /dev/null
+## Community mirror of Cloudsmith: RabbitMQ repository
+curl -1sLf https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-server.9F4587F226208342.key | gpg --dearmor | tee /usr/share/keyrings/rabbitmq.9F4587F226208342.gpg > /dev/null
+
+## Add apt repositories maintained by Team RabbitMQ
+tee /etc/apt/sources.list.d/rabbitmq.list <<EOF
+## Provides modern Erlang/OTP releases
+##
+deb [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.novemberain.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
+deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa1.novemberain.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
+
+# another mirror for redundancy
+deb [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.novemberain.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
+deb-src [signed-by=/usr/share/keyrings/rabbitmq.E495BB49CC4BBE5B.gpg] https://ppa2.novemberain.com/rabbitmq/rabbitmq-erlang/deb/ubuntu jammy main
+
+## Provides RabbitMQ
+##
+deb [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.novemberain.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
+deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa1.novemberain.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
+
+# another mirror for redundancy
+deb [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.novemberain.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
+deb-src [signed-by=/usr/share/keyrings/rabbitmq.9F4587F226208342.gpg] https://ppa2.novemberain.com/rabbitmq/rabbitmq-server/deb/ubuntu jammy main
+EOF
+
+## Update package indices
+apt-get update -y
+
+## Install Erlang packages
+apt-get install -y erlang-base \
+                        erlang-asn1 erlang-crypto erlang-eldap erlang-ftp erlang-inets \
+                        erlang-mnesia erlang-os-mon erlang-parsetools erlang-public-key \
+                        erlang-runtime-tools erlang-snmp erlang-ssl \
+                        erlang-syntax-tools erlang-tftp erlang-tools erlang-xmerl
+
+## Install rabbitmq-server and its dependencies
+apt-get install rabbitmq-server -y --fix-missing

mhagenta-1.0.0/mhagenta/core/__init__.py

@@ -0,0 +1,6 @@
+from .processes import MHAProcess
+from .orchestrator import Orchestrator
+from .connection import Connector, RabbitMQConnector
+
+
+__all__ = ['Connector', 'RabbitMQConnector', 'MHAProcess', 'Orchestrator']

mhagenta-1.0.0/mhagenta/core/agent_launcher.py

@@ -0,0 +1,27 @@
+import os
+import dill
+import asyncio
+from typing import Any
+
+from mhagenta.core.processes import MHARoot
+from mhagenta.modules import *
+from mhagenta.states import *
+from mhagenta.utils import ModuleTypes, Observation, ActionStatus
+from mhagenta.core.processes import run_agent_module, MHAModule, ModuleBase, GlobalParams
+from mhagenta.bases import *
+
+
+async def main():
+    with open('/agent/agent_params', 'rb') as f:
+        params: dict[str, Any] = dill.load(f)
+
+    id_override = os.environ.get('AGENT_ID')
+    if id_override is not None and id_override != '':
+        params['agent_id'] = os.environ.get('AGENT_ID')
+    agent = MHARoot(**params)
+    await agent.initialize()
+    await agent.start()
+
+
+if __name__ == '__main__':
+    asyncio.run(main())

mhagenta-1.0.0/mhagenta/core/connection/__init__.py

@@ -0,0 +1,7 @@
+from .connector import Connector
+from .module_messenger import ModuleMessenger
+from .root_messenger import RootMessenger
+from .rabbitmq_connector import RabbitMQConnector
+
+
+__all__ = ['Connector', 'ModuleMessenger', 'RootMessenger', 'RabbitMQConnector']

mhagenta-1.0.0/mhagenta/core/connection/connector.py

@@ -0,0 +1,96 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Callable, Iterable
+
+import dill
+
+from mhagenta.utils.common import Message, MHABase, StatusReport, AgentCmd, ModuleTypes, AgentTime, LoggerExtras, \
+    DEFAULT_LOG_FORMAT
+from mhagenta.utils.common.typing import MsgProcessorCallback
+
+
+class Connector(MHABase, ABC):
+    def __init__(self,
+                 agent_id: str,
+                 sender_id: str,
+                 agent_time: AgentTime,
+                 log_tags: list[str] = '',
+                 log_level: int | str = logging.DEBUG,
+                 log_format: str = DEFAULT_LOG_FORMAT,
+                 *args, **kwargs
+                 ) -> None:
+        super().__init__(
+            agent_id=agent_id,
+            log_tags=log_tags,
+            log_level=log_level,
+            log_format=log_format
+        )
+        self._id = self.__class__.__name__
+        self._sender_id = sender_id
+        self._time = agent_time
+
+    @abstractmethod
+    async def start(self) -> None:
+        pass
+
+    @abstractmethod
+    async def stop(self) -> None:
+        pass
+
+    @abstractmethod
+    async def subscribe_to_in_channel(self, sender: str, channel: str, callback: MsgProcessorCallback, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def register_out_channel(self, recipient: str, channel: str, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def subscribe_to_cmds(self, callback: Callable[[AgentCmd], None], **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def register_cmd_out_channel(self, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def subscribe_to_statuses(self, callback: Callable[[StatusReport], None], **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    async def register_status_out_channel(self, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    def send(self, recipient: str, channel: str, msg: Message, **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    def cmd(self,
+            cmd: AgentCmd,
+            module_types: str | Iterable[str] = ModuleTypes.ALL,
+            module_ids: str | Iterable[str] = ModuleTypes.ALL,
+            **kwargs) -> None:
+        pass
+
+    @abstractmethod
+    def status(self, status: StatusReport, **kwargs) -> None:
+        pass
+
+    @staticmethod
+    def encode_msg(msg: Message) -> bytes:
+        return dill.dumps(msg)
+
+    @staticmethod
+    def decode_msg(msg: bytes) -> Message:
+        return dill.loads(msg)
+
+    @property
+    def _logger_extras(self) -> LoggerExtras | None:
+        return LoggerExtras(
+            agent_time=self._time.agent,
+            mod_time=self._time.module,
+            exec_time=str(self._time.exec) if self._time.exec is not None else '-',
+            tags=self.log_tag_str
+        )
+

mhagenta-1.0.0/mhagenta/core/connection/module_messenger.py

@@ -0,0 +1,93 @@
+import asyncio
+import logging
+from typing import Iterable, Callable
+
+from mhagenta.utils.common import MHABase, AgentTime, DEFAULT_LOG_FORMAT
+from mhagenta.utils.common.typing import MsgProcessorCallback, Sender, Recipient, Channel
+from mhagenta.core.connection.connector import Connector
+from mhagenta.utils import Message, AgentCmd, StatusReport, LoggerExtras
+
+
+class ModuleMessenger(MHABase):
+    def __init__(self,
+                 connector_cls: type[Connector],
+                 agent_id: str,
+                 module_type: str,
+                 module_id: str,
+                 agent_time: AgentTime,
+                 out_id_channels: Iterable[tuple[Recipient, Channel]],
+                 in_id_channel_callbacks: Iterable[tuple[Sender, Channel, MsgProcessorCallback]],
+                 agent_cmd_callback: Callable[[AgentCmd], None],
+                 log_tags: list[str],
+                 log_level: int | str = logging.DEBUG,
+                 log_format: str = DEFAULT_LOG_FORMAT,
+                 **kwargs
+                 ) -> None:
+        super().__init__(
+            agent_id=agent_id,
+            log_tags=log_tags,
+            log_level=log_level,
+            log_format=log_format
+        )
+
+        self._time = agent_time
+        self._out_id_channels = out_id_channels
+        self._in_id_channel_callbacks = in_id_channel_callbacks
+        self._agent_cmd_callback = agent_cmd_callback
+
+        self._connector = connector_cls(
+            agent_id=agent_id,
+            sender_id=f'{module_type}.{module_id}',
+            agent_time=self._time,
+            log_tags=self._log_tags,
+            log_level=log_level,
+            log_format=log_format,
+            **kwargs
+        )
+
+    async def initialize(self) -> None:
+        await self._connector.initialize()
+
+        async with asyncio.TaskGroup() as tg:
+            tasks: list[asyncio.Task] = list()
+            for recipient, channel in self._out_id_channels:
+                tasks.append(tg.create_task(self._connector.register_out_channel(recipient=recipient, channel=channel)))
+            for sender, channel, callback in self._in_id_channel_callbacks:
+                tasks.append(tg.create_task(self._connector.subscribe_to_in_channel(sender=sender, channel=channel, callback=self._msg_callback_generator(callback))))
+            tasks.append(tg.create_task(self._connector.subscribe_to_cmds(self._cmd_callback_generator(self._agent_cmd_callback))))
+            tasks.append(tg.create_task(self._connector.register_status_out_channel()))
+
+    async def start(self) -> None:
+        await self._connector.start()
+
+    async def stop(self) -> None:
+        await self._connector.stop()
+
+    def send(self, recipient: str, channel: str, msg: Message) -> None:
+        self._connector.send(recipient, channel, msg)
+        self.debug(f'Sent {msg}')
+
+    def _msg_callback_generator(self, msg_callback: Callable[[Sender, Channel, Message], None]) -> Callable[[Sender, Channel, Message], None]:
+        def callback(sender: str, channel: str, msg: Message) -> None:
+            self.debug(f'Received {msg}')
+            msg_callback(sender, channel, msg)
+        return callback
+
+    def report_status(self, status: StatusReport) -> None:
+        self._connector.status(status)
+        self.debug(f'Reported {status}')
+
+    def _cmd_callback_generator(self, cmd_callback: Callable[[AgentCmd], None]) -> Callable[[AgentCmd], None]:
+        def callback(cmd: AgentCmd) -> None:
+            self.debug(f'Received {cmd}')
+            cmd_callback(cmd)
+        return callback
+
+    @property
+    def _logger_extras(self) -> LoggerExtras | None:
+        return LoggerExtras(
+            agent_time=self._time.agent,
+            mod_time=self._time.module,
+            exec_time=str(self._time.exec) if self._time.exec is not None else '-',
+            tags=self.log_tag_str
+        )