1.workflow has reached a state of basic functionality.

2. implemented AI message bus infrastructure,

src/component/agent_manager/agent_manager.py

@@ -10,10 +10,6 @@ logger = logging.getLogger(__name__)
 
 class AgentManager:
     _instance = None
-
-    def __init__(self) -> None:
-        self.loaded_agent_instance = {}
-        pass
    
     def __new__(cls):
         if cls._instance is None:
@@ -22,8 +18,10 @@ class AgentManager:
     
 
     def initial(self,root_dir:str) -> None:
-        self.agent_templete_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}templetes/templetes.cfg")
-        self.agent_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}agents/agents.cfg")
+        self.agent_templete_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}/templetes/templetes.cfg")
+        self.agent_env : PackageEnv = PackageEnvManager().get_env(f"{root_dir}/agents/agents.cfg")
+        self.db_path = f"{root_dir}/agents_chat.db"
+        self.loaded_agent_instance = {}
         if self.agent_templete_env is None:
             raise Exception("agent_manager initial failed")
         
@@ -41,8 +39,8 @@ class AgentManager:
         the_agent : AIAgent = await self._load_agent_from_media(agent_media_info)
         if the_agent is None:
             logger.warn(f"load agent {agent_id} from media failed!")
-        else:
-            the_agent.start()    
+            
+        the_agent.chat_db = self.db_path
         return the_agent
 
     def remove(self,agent_id:str)->int:

src/component/workflow_manager/workflow_manager.py

@@ -1,11 +1,74 @@
+import logging
+import toml
 from aios_kernel import Workflow
+from package_manager import PackageEnv,PackageEnvManager,PackageMediaInfo,PackageInstallTask
+from agent_manager import AgentManager
+logger = logging.getLogger(__name__)
+import os
 
 class WorkflowManager:
-    def __init__(self) -> None:
-        pass
-    
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(WorkflowManager, cls).__new__(cls)
+        return cls._instance
+
+
     def initial(self,root_dir:str) -> None:
+        self.loaded_workflow = {}
+        self.workflow_env = PackageEnvManager().get_env(f"{root_dir}/workflows.cfg")
+        self.db_file = os.path.abspath(f"{root_dir}/workflows.db")
+        if self.workflow_env is None:
+            raise Exception("WorkflowManager initial failed")
+        
+    async def get_agent_default_workflow(self,agent_id:str) -> Workflow:
         pass
 
-    def get_workflow(self,workflow_id:str) -> Workflow:
-        pass
+    async def get_workflow(self,workflow_id:str) -> Workflow:
+        the_workflow : Workflow = self.loaded_workflow.get(workflow_id)
+        if the_workflow:
+            return the_workflow
+        
+        # try load from disk
+        workflow_media_info = self.workflow_env.load(workflow_id)
+        if workflow_media_info is None:
+            return None
+        
+        the_workflow = await self._load_workflow_from_media(workflow_media_info)
+        if the_workflow is None:
+            logger.warn(f"load workflow {workflow_id} from media failed!")
+
+        for v in the_workflow.role_group.roles.values():
+            agent = await AgentManager().get(v.agent_name)
+            if agent is None:
+                logger.error(f"load agent {v.agent_name} failed!")
+                return None
+            v.agent = agent
+
+
+        return the_workflow
+    
+    async def _load_workflow_from_media(self,workflow_media:PackageMediaInfo) -> Workflow:
+        reader = self.workflow_env._create_media_loader(workflow_media)
+        if reader is None:
+            logger.error(f"create media loader for {workflow_media} failed!")
+            return None
+        
+        try:
+            config_file = await reader.read("workflow.toml","r")
+            if config_file is None:
+                logger.error(f"read workflow config from {workflow_media} failed!")
+                return None
+
+            config_data = await config_file.read()
+            config = toml.loads(config_data)
+            result_workflow = Workflow()
+            if result_workflow.load_from_config(config) is False:
+                logger.error(f"load workflow from {workflow_media} failed!")
+                return None
+            result_workflow.db_file = self.db_file
+            return result_workflow
+        except Exception as e:
+            logger.error(f"read workflow.toml cfg from {workflow_media} failed! unexpected error occurred: {str(e)}")
+            return None