feat(agent): dbgpts support agent (#1417)

dbgpt/agent/core/agent_manage.py

@@ -3,14 +3,12 @@
 import logging
 import re
 from collections import defaultdict
-from typing import Dict, List, Type
+from typing import Dict, List, Optional, Set, Tuple, Type, cast
+
+from dbgpt.component import BaseComponent, ComponentType, SystemApp
 
-from ..expand.code_assistant_agent import CodeAssistantAgent
-from ..expand.dashboard_assistant_agent import DashboardAssistantAgent
-from ..expand.data_scientist_agent import DataScientistAgent
-from ..expand.plugin_assistant_agent import PluginAssistantAgent
-from ..expand.summary_assistant_agent import SummaryAssistantAgent
 from .agent import Agent
+from .base_agent import ConversableAgent
 
 logger = logging.getLogger(__name__)
 
@@ -46,62 +44,117 @@ def mentioned_agents(message_content: str, agents: List[Agent]) -> Dict:
     return mentions
 
 
-class AgentManager:
+class AgentManager(BaseComponent):
     """Manages the registration and retrieval of agents."""
 
-    def __init__(self):
+    name = ComponentType.AGENT_MANAGER
+
+    def __init__(self, system_app: SystemApp):
         """Create a new AgentManager."""
-        self._agents = defaultdict()
+        super().__init__(system_app)
+        self.system_app = system_app
+        self._agents: Dict[
+            str, Tuple[Type[ConversableAgent], ConversableAgent]
+        ] = defaultdict()
 
-    def register_agent(self, cls):
+        self._core_agents: Set[str] = set()
+
+    def init_app(self, system_app: SystemApp):
+        """Initialize the AgentManager."""
+        self.system_app = system_app
+
+    def after_start(self):
+        """Register all agents."""
+        from ..expand.code_assistant_agent import CodeAssistantAgent
+        from ..expand.dashboard_assistant_agent import DashboardAssistantAgent
+        from ..expand.data_scientist_agent import DataScientistAgent
+        from ..expand.plugin_assistant_agent import PluginAssistantAgent
+        from ..expand.summary_assistant_agent import SummaryAssistantAgent
+
+        core_agents = set()
+        core_agents.add(self.register_agent(CodeAssistantAgent))
+        core_agents.add(self.register_agent(DashboardAssistantAgent))
+        core_agents.add(self.register_agent(DataScientistAgent))
+        core_agents.add(self.register_agent(SummaryAssistantAgent))
+        core_agents.add(self.register_agent(PluginAssistantAgent))
+        self._core_agents = core_agents
+
+    def register_agent(
+        self, cls: Type[ConversableAgent], ignore_duplicate: bool = False
+    ) -> str:
         """Register an agent."""
-        self._agents[cls().profile] = cls
+        inst = cls()
+        profile = inst.get_profile()
+        if profile in self._agents and (
+            profile in self._core_agents or not ignore_duplicate
+        ):
+            raise ValueError(f"Agent:{profile} already register!")
+        self._agents[profile] = (cls, inst)
+        return profile
 
-    def get_by_name(self, name: str) -> Type[Agent]:
+    def get_by_name(self, name: str) -> Type[ConversableAgent]:
         """Return an agent by name.
 
         Args:
             name (str): The name of the agent to retrieve.
 
         Returns:
-            Type[Agent]: The agent with the given name.
+            Type[ConversableAgent]: The agent with the given name.
 
         Raises:
             ValueError: If the agent with the given name is not registered.
         """
         if name not in self._agents:
             raise ValueError(f"Agent:{name} not register!")
-        return self._agents[name]
+        return self._agents[name][0]
 
     def get_describe_by_name(self, name: str) -> str:
         """Return the description of an agent by name."""
-        return self._agents[name].desc
+        return self._agents[name][1].desc
 
     def all_agents(self):
         """Return a dictionary of all registered agents and their descriptions."""
         result = {}
-        for name, cls in self._agents.items():
-            result[name] = cls.desc
+        for name, value in self._agents.items():
+            result[name] = value[1].desc
         return result
 
     def list_agents(self):
         """Return a list of all registered agents and their descriptions."""
         result = []
-        for name, cls in self._agents.items():
-            instance = cls()
+        for name, value in self._agents.items():
             result.append(
                 {
-                    "name": instance.profile,
-                    "desc": instance.goal,
+                    "name": value[1].profile,
+                    "desc": value[1].goal,
                 }
             )
         return result
 
 
-agent_manager = AgentManager()
+_SYSTEM_APP: Optional[SystemApp] = None
 
-agent_manager.register_agent(CodeAssistantAgent)
-agent_manager.register_agent(DashboardAssistantAgent)
-agent_manager.register_agent(DataScientistAgent)
-agent_manager.register_agent(SummaryAssistantAgent)
-agent_manager.register_agent(PluginAssistantAgent)
+
+def initialize_agent(system_app: SystemApp):
+    """Initialize the agent manager."""
+    global _SYSTEM_APP
+    _SYSTEM_APP = system_app
+    agent_manager = AgentManager(system_app)
+    system_app.register_instance(agent_manager)
+
+
+def get_agent_manager(system_app: Optional[SystemApp] = None) -> AgentManager:
+    """Return the agent manager.
+
+    Args:
+        system_app (Optional[SystemApp], optional): The system app. Defaults to None.
+
+    Returns:
+        AgentManager: The agent manager.
+    """
+    if not _SYSTEM_APP:
+        if not system_app:
+            system_app = SystemApp()
+        initialize_agent(system_app)
+    app = system_app or _SYSTEM_APP
+    return AgentManager.get_instance(cast(SystemApp, app))

dbgpt/agent/core/base_agent.py

@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 
 
 class ConversableAgent(Role, Agent):
-    """ConversableAgent is a agent that can communicate with other agents."""
+    """ConversableAgent is an agent that can communicate with other agents."""
 
     agent_context: Optional[AgentContext] = Field(None, description="Agent context")
     actions: List[Action] = Field(default_factory=list)