1) Add e-mail tunnel support 2) Modify all __new__ to get_instance() 3) init docker build scripts

src/aios_kernel/__init__.py

@@ -10,4 +10,5 @@ from .workflow import Workflow
 from .bus import AIBus
 from .workflow_env import WorkflowEnvironment,CalenderEnvironment,CalenderEvent
 from .tunnel import AgentTunnel
-from .tg_tunnel import TelegramTunnel
+from .tg_tunnel import TelegramTunnel
+from .email_tunnel import EmailTunnel

src/aios_kernel/agent.py

@@ -82,7 +82,7 @@ class AIAgent:
         self.chat_db = None
         self.unread_msg = Queue() # msg from other agent
         self.owner_env : Environment = None
-        self.owenr_bus : AIBus = None
+        self.owenr_bus = None
         
     @classmethod
     def create_from_templete(cls,templete:AIAgentTemplete, fullname:str):
@@ -164,7 +164,7 @@ class AIAgent:
         
         inner_functions = self._get_inner_functions()
         prompt.messages.append({"role":"function","content":result_str,"name":func_name})
-        task_result:ComputeTaskResult = await ComputeKernel().do_llm_completion(prompt,self.llm_model_name,self.max_token_size,inner_functions)
+        task_result:ComputeTaskResult = await ComputeKernel.get_instance().do_llm_completion(prompt,self.llm_model_name,self.max_token_size,inner_functions)
         
         ineternal_call_record.result_str = task_result.result_str
         ineternal_call_record.done_time = time.time()
@@ -198,7 +198,7 @@ class AIAgent:
 
             inner_functions = self._get_inner_functions()
 
-            task_result:ComputeTaskResult = await ComputeKernel().do_llm_completion(prompt,self.llm_model_name,self.max_token_size,inner_functions)
+            task_result:ComputeTaskResult = await ComputeKernel.get_instance().do_llm_completion(prompt,self.llm_model_name,self.max_token_size,inner_functions)
             final_result = task_result.result_str
 
             inner_func_call_node = task_result.result_message.get("function_call")

src/aios_kernel/compute_kernel.py

@@ -17,19 +17,14 @@ logger = logging.getLogger(__name__)
 
 class ComputeKernel:
     _instance = None
-
-    def __new__(cls):
+    @classmethod
+    def get_instance(cls):
         if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance.is_start = False
-
+            cls._instance = ComputeKernel()
         return cls._instance
-
+    
     def __init__(self) -> None:
-        if self.is_start is True:
-            return
-
-        self.is_start = True
+        self.is_start = False
         self.task_queue = Queue()
         self.is_start = False
         self.compute_nodes = {}

src/aios_kernel/email_tunnel.py

@@ -0,0 +1,143 @@
+import asyncio
+import aiosmtplib
+import aioimaplib
+import email
+from email.header import decode_header
+import mailparser
+import logging
+import time
+import datetime
+from .tunnel import AgentTunnel
+from .agent_message import AgentMsg
+
+from email.message import EmailMessage
+
+logger = logging.getLogger(__name__)
+
+class EmailTunnel(AgentTunnel):
+    @classmethod
+    def register_to_loader(cls):
+        async def load_email_tunnel(config:dict) -> AgentTunnel:
+            result_tunnel = EmailTunnel()
+            if await result_tunnel.load_from_config(config):
+                return result_tunnel
+            else:
+                return None
+            
+        AgentTunnel.register_loader("EmailTunnel",load_email_tunnel)
+
+    async def load_from_config(self,config:dict)->bool:
+        self.target_id = config["target"]
+        self.tunnel_id = config["tunnel_id"]
+
+        self.type = "TelegramTunnel"
+        self.email = config["email"]
+        self.imap_server = config["imap"]
+        s = self.imap_server.split(":")
+        if len(s) == 2:
+            self.imap_server = s[0]
+            self.imap_port = int(s[1])
+
+        self.smtp_server = config["smtp"]   
+        s = self.smtp_server.split(":")
+        if len(s) == 2:
+            self.smtp_server = s[0]
+            self.smtp_port = int(s[1])
+
+        self.login_user = config["user"]
+        self.login_password = config["password"]
+        self.folder = config["folder"]
+        self.check_interval = config["interval"]
+
+        return True  
+    
+    def __init__(self) -> None:
+        super().__init__()
+        self.is_start = False
+        self.read_email = {}
+
+    async def on_new_email(self,mail:mailparser.MailParser) -> None:
+        remote_email_addr = mail.from_[0][1]
+        remote_user_name = remote_email_addr.split("@")[0] 
+        agent_msg = self.conver_mail_to_agent_msg(mail)
+        agent_msg.sender = remote_user_name
+        agent_msg.target = self.target_id
+        self.ai_bus.register_message_handler(remote_user_name, self._process_message)
+
+        resp_msg = await self.ai_bus.send_message(agent_msg)
+        if resp_msg is None:
+            await self.reply_email(remote_email_addr,"Sorry, I can't understand your message","")
+        else:
+            if resp_msg.body_mime is None:
+                await self.reply_email(remote_email_addr,"result",resp_msg.body)
+
+    async def reply_email(self,target_email:str,title:str,msg:str) -> None:
+        email_msg = EmailMessage()
+        email_msg['Subject'] = f"Reply: {title}"
+        email_msg['From'] = self.email
+        email_msg['To'] = target_email
+        email_msg.set_content(msg)
+
+        await aiosmtplib.send(
+            email_msg,
+            hostname = self.smtp_server,
+            port=self.smtp_port,
+            username=self.login_user,
+            password=self.login_password,
+            )
+
+
+
+    def conver_mail_to_agent_msg(self,mail:mailparser.MailParser) -> AgentMsg:
+        msg = AgentMsg()
+        msg.set("",self.target_id,mail.text_plain[0])
+        msg.topic = "email"
+        return msg
+
+    async def check_email(self) -> None:
+        self.last_check_num = 0
+        self.last_check_time = datetime.datetime.now()
+        while True:
+            if self.is_start == False:
+                return
+            
+            await asyncio.sleep(self.check_interval)
+            imap_client = aioimaplib.IMAP4_SSL(host=self.imap_server,port=self.imap_port)
+            await imap_client.wait_hello_from_server()
+            await imap_client.login(self.login_user, self.login_password)
+
+            date_since = self.last_check_time.strftime("%d-%b-%Y")
+            
+            await imap_client.select(self.folder)
+            status, messages = await imap_client.search('UNSEEN',charset='US-ASCII')
+            self.last_check_time = datetime.datetime.now()
+            if status == "OK":
+                message_numbers = messages[0].split()
+                for num in message_numbers:
+                    num = int(num)
+                    if self.read_email.get(num) is not None:
+                        continue
+                    
+                    status, email_data = await imap_client.fetch(str(num), "(RFC822)")
+                    if status == "OK":
+                        #r = email.message_from_bytes(email_data[1])
+                        mail = mailparser.parse_from_bytes(email_data[1])
+                        self.read_email[num] = mail
+                        await self.on_new_email(mail)
+
+            await imap_client.logout()
+
+    async def start(self) -> bool:
+        if self.is_start:
+            logger.warning(f"tunnel {self.tunnel_id} is already started")
+            return False
+        self.is_start = True   
+
+        asyncio.create_task(self.check_email())
+        return True
+
+    async def close(self) -> None:
+        self.is_start = False
+
+    async def _process_message(self, msg: AgentMsg) -> None:
+        logger.warn(f"process message {msg.msg_id} from {msg.sender} to {msg.target}")

src/aios_kernel/open_ai_node.py

@@ -13,20 +13,17 @@ logger = logging.getLogger(__name__)
 
 class OpenAI_ComputeNode(ComputeNode):
     _instance = None
-
-    def __new__(cls):
+    @classmethod
+    def get_instance(cls):
         if cls._instance is None:
-            cls._instance = super(OpenAI_ComputeNode, cls).__new__(cls)
-            cls._instance.is_start = False
+            cls._instance = OpenAI_ComputeNode()
         return cls._instance
+    
 
     def __init__(self) -> None:
         super().__init__()
-        if self.is_start is True:
-            logger.warn("OpenAI_ComputeNode is already start")
-            return
 
-        self.is_start = True
+        self.is_start = False
         # openai.organization = "org-AoKrOtF2myemvfiFfnsSU8rF" #buckycloud
         self.openai_api_key = ""
         self.node_id = "openai_node"
@@ -89,6 +86,10 @@ class OpenAI_ComputeNode(ComputeNode):
         return result
 
     def start(self):
+        if self.is_start is True:
+            return
+        self.is_start = True
+        
         async def _run_task_loop():
             while True:
                 task = await self.task_queue.get()

src/aios_kernel/stability_node.py

@@ -16,20 +16,17 @@ logger = logging.getLogger(__name__)
 
 class Stability_ComputeNode(ComputeNode):
     _instanace = None
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = Stability_ComputeNode()
+        return cls._instance
 
-    def __new__(cls):
-        if cls._instanace is None:
-            cls._instanace = super(Stability_ComputeNode, cls).__new__(cls)
-            cls._instanace.is_start = False
-        return cls._instanace
 
     def __init__(self) -> None:
         super().__init__()
-        if self.is_start is True:
-            logger.warn("Stability_ComputeNode is already start")
-            return
 
-        self.is_start = True
+        self.is_start = False
         self.node_id = "stability_node"
         self.api_key = ""
         self.engine = "stable-diffusion-512-v2-1"
@@ -88,8 +85,8 @@ class Stability_ComputeNode(ComputeNode):
 
         for resp in answers:
             for artifact in resp.artifacts:
-                logger.info("artifact:", artifact.id,
-                            artifact.type, artifact.finish_reason)
+                logger.info(f"artifact:{artifact.id},{artifact.type},{artifact.finish_reason}")
+                
                 if artifact.finish_reason == generation.FILTER:
                     logging.warn("request activated the API's safety filters")
                 if artifact.type == generation.ARTIFACT_IMAGE:
@@ -108,6 +105,9 @@ class Stability_ComputeNode(ComputeNode):
         return None
 
     def start(self):
+        if self.is_start:
+            return
+        self.is_start = True
         async def _run_task_loop():
             while True:
                 logger.info("stability_node is waiting for task...")

src/aios_kernel/workflow.py

@@ -122,7 +122,11 @@ class Workflow:
         connected_env_ndoe = config.get("connected_env") 
         if  connected_env_ndoe is not None:
            for _node in connected_env_ndoe:
-                remote_env = Environment.get_env_by_id(_node.get("env_id"))
+                env_id = _node.get("env_id")
+                if env_id is None:
+                    continue
+
+                remote_env = Environment.get_env_by_id(_node.get(env_id))
                 if remote_env is None:
                      logger.error(f"Workflow load connected_env failed, env {env_id} not found!")
                      return False
@@ -391,7 +395,7 @@ class Workflow:
         
         inner_functions = self._get_inner_functions()
         prompt.messages.append({"role":"function","content":result_str,"name":func_name})
-        task_result:ComputeTaskResult = await ComputeKernel().do_llm_completion(prompt,
+        task_result:ComputeTaskResult = await ComputeKernel.get_instance().do_llm_completion(prompt,
                                                                                 the_role.agent.llm_model_name,the_role.agent.max_token_size,
                                                                                 inner_functions)
         
@@ -431,7 +435,7 @@ class Workflow:
         
         async def _do_process_msg():
             #TODO: send msg to agent might be better?
-            task_result:ComputeTaskResult = await ComputeKernel().do_llm_completion(prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size(),inner_functions)
+            task_result:ComputeTaskResult = await ComputeKernel.get_instance().do_llm_completion(prompt,the_role.agent.get_llm_model_name(),the_role.agent.get_max_token_size(),inner_functions)
             result_str = task_result.result_str
             logger.info(f"{the_role.role_id} process {msg.sender}:{msg.body},llm str is :{result_str}")