Add tunnel support ,and implment TelegramTunnel. Now we can use telegram bot connect to installed agent/workflow.

src/aios_kernel/__init__.py

@@ -8,4 +8,6 @@ from .open_ai_node import OpenAI_ComputeNode
 from .role import AIRole,AIRoleGroup
 from .workflow import Workflow
 from .bus import AIBus
-from .workflow_env import WorkflowEnvironment,CalenderEnvironment,CalenderEvent
+from .workflow_env import WorkflowEnvironment,CalenderEnvironment,CalenderEvent
+from .tunnel import AgentTunnel
+from .tg_tunnel import TelegramTunnel

src/aios_kernel/agent.py

@@ -243,8 +243,8 @@ class AIAgent:
         result_prompt = AgentPrompt()
         for msg in reversed(messages):
             if msg.target == chatsession.owner_id:
-                result_prompt.messages.append({"role":"user","content":f"{msg.sender}:{msg.body}"})
-            if msg.sender == chatsession.owner_id:
+                result_prompt.messages.append({"role":"user","content":msg.body})
+            elif msg.sender == chatsession.owner_id:
                 result_prompt.messages.append({"role":"assistant","content":msg.body})
         
         return result_prompt

src/aios_kernel/contact_manager.py

@@ -0,0 +1,34 @@
+from typing import List
+
+class Contact:
+    def __init__(self,name:str) -> None:
+        self.name = name
+        self.tags = []
+
+    def is_zone_owner(self,zone_id=None) -> bool:
+        return True
+
+    def get_tags(self)->List[str]:
+        return self.tags
+
+    def get_name(self)->str:
+        return self.name
+
+
+class ContactManager:
+    _instance = None
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = ContactManager()
+        return cls._instance
+
+    def __init__(self) -> None:
+        self.contacts = {}
+        self.contacts["liuzhicong"] = Contact("liuzhicong")
+
+    #def get_by_addr(self,addr:str) -> Contact:
+    #    pass
+
+    def get_by_name(self,name:str) -> Contact:
+        return self.contacts.get(name)

src/aios_kernel/tg_tunnel.py

@@ -0,0 +1,116 @@
+import logging
+import threading
+import asyncio
+import uuid
+
+from typing import Callable
+
+from telegram import ForceReply, Update
+from telegram.ext import Application, CommandHandler, ContextTypes, MessageHandler, filters
+
+from .tunnel import AgentTunnel
+from .contact_manager import ContactManager
+from .agent_message import AgentMsg
+
+logger = logging.getLogger(__name__)
+
+class TelegramTunnel(AgentTunnel):
+
+    @classmethod
+    def register_to_loader(cls):
+        async def load_tg_tunnel(config:dict) -> AgentTunnel:
+            result_tunnel = TelegramTunnel("")
+            if await result_tunnel.load_from_config(config):
+                return result_tunnel
+            else:
+                return None
+            
+        AgentTunnel.register_loader("TelegramTunnel",load_tg_tunnel)
+
+        
+    async def load_from_config(self,config:dict)->bool:
+        self.tg_token = config["token"]
+        self.target_id = config["target"]
+        self.tunnel_id = config["tunnel_id"]
+        self.type = "TelegramTunnel"
+        return True
+
+    def dump_to_config(self) -> dict:
+        pass
+
+    def __init__(self,tg_token:str) -> None:
+        super().__init__()
+        self.is_start = False
+        self.tg_token = tg_token
+        #self.tunnel_id = "tg_tunnel#" + self.app.bot.id
+
+    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   
+
+        self.app:Application = Application.builder().token(self.tg_token).build()
+        self.app.add_handler(MessageHandler(filters.TEXT, self.on_message))
+
+        def _run_app():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self.app.run_polling(allowed_updates=Update.ALL_TYPES)
+
+        self.poll_thread = threading.Thread(target=_run_app)
+        self.poll_thread.start()
+        return True
+
+    async def close(self) -> None:
+        pass
+
+    async def _process_message(self, msg: AgentMsg) -> None:
+        logger.warn(f"process message {msg.msg_id} from {msg.sender} to {msg.target}")
+
+    async def conver_tg_msg_to_agent_msg(self,update:Update) -> AgentMsg:
+        agent_msg = AgentMsg()
+        agent_msg.topic = "_telegram"
+        agent_msg.msg_id = "tg_msg#" + str(update.message.message_id) + "#" + uuid.uuid4().hex
+        agent_msg.target = self.target_id
+        agent_msg.body = update.message.text
+        agent_msg.create_time = update.message.date.timestamp()
+        #if update.message.photo is not None:
+        #    agent_msg.body_mime = "image"
+        #    agent_msg.body = update.message.photo[-1].get_file().download()
+        return agent_msg
+
+
+
+    async def on_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        cm = ContactManager.get_instance()
+        reomte_user_name = f"{update.effective_user.id}@telegram"
+        #contact = cm.get_by_name(update.effective_user.username)
+        #if contact is not None:
+        #    reomte_user_name = contact.get_name()
+        #if contact is None:
+        #    update.message.reply_text(f"{self.target_id} process message error, unknown user!")
+        #if not contact.is_zone_owner():
+        #    update.message.reply_text(f"{self.target_id} process message error, you are not my owner!")
+
+        agent_msg = await self.conver_tg_msg_to_agent_msg(update)
+        agent_msg.sender = reomte_user_name
+        self.ai_bus.register_message_handler(reomte_user_name, self._process_message)
+        resp_msg = await self.ai_bus.send_message(agent_msg)
+        if resp_msg is None:
+            await update.message.reply_text(f"{self.target_id} process message error")
+        else:
+            if resp_msg.body_mime is None:
+                await update.message.reply_text(resp_msg.body)
+            else:
+                if resp_msg.body_mime.startswith("image"):
+                    photo_file = open(resp_msg.body,"rb")
+                    if photo_file:
+                        await update.message.reply_photo(resp_msg.body)
+                    else:
+                        await update.message.reply_text(resp_msg.body)
+                else:
+                    await update.message.reply_text(resp_msg.body)
+            
+        
+        

src/aios_kernel/tunnel.py

@@ -0,0 +1,63 @@
+from abc import ABC, abstractmethod
+import logging
+from typing import Coroutine
+from .agent_message import AgentMsg
+from .bus import AIBus
+
+logger = logging.getLogger(__name__)
+
+class AgentTunnel(ABC):
+    _all_loader = {}
+    _all_tunnels = {}
+    @classmethod
+    def register_loader(cls,tunnel_type:str,loader:Coroutine) -> None:
+        cls._all_loader[tunnel_type] = loader
+
+    @classmethod
+    async def load_all_tunnels_from_config(cls,config:dict) -> None:
+        for tunnel_config in config:
+            loader = cls._all_loader.get(tunnel_config["type"])
+            if loader is not None:
+                tunnel = await loader(tunnel_config)
+                if tunnel is not None:
+                    cls._all_tunnels[tunnel.tunnel_id] = tunnel
+                    tunnel.connect_to(AIBus.get_default_bus(),tunnel.target_id)
+                    await tunnel.start()
+                else:
+                    logger.error(f"load tunnel {tunnel_config['tunnel_id']} failed") 
+            else:
+                logger.error(f"load tunnel {tunnel_config['type']} failed,loader not found")
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.tunnel_id = None
+        self.target_id = None
+        self.target_type = None
+        self.ai_bus = None
+        self.is_connected = False
+
+    def connect_to(self, ai_bus:AIBus,target_id: str) -> None:
+        """
+        Connect to the agent with the given id
+        """
+        if self.is_connected:
+            logger.warning(f"tunnel {self.tunnel_id} is already connected to {self.target_id}")
+            return
+        self.target_id = target_id
+        self.target_type = "agent"
+        self.ai_bus = ai_bus
+        self.is_connected = True
+
+        
+
+    @abstractmethod
+    async def start(self) -> bool:
+        pass
+
+    @abstractmethod
+    async def close(self) -> None:
+        pass
+
+    @abstractmethod
+    async def _process_message(self, msg: AgentMsg) -> None:
+        pass