146 lines
No EOL
5.6 KiB
Python
146 lines
No EOL
5.6 KiB
Python
"""
|
|
Aktualisierte Registry für alle verfügbaren Agenten im System.
|
|
Enthält jetzt auch den FileCreator-Agenten.
|
|
"""
|
|
|
|
import logging
|
|
import importlib
|
|
from typing import Dict, Any, List, Optional
|
|
|
|
# Import direkt bekannter Agent-Module
|
|
# Andere Module werden dynamisch importiert
|
|
from modules.agentservice_base import BaseAgent
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class AgentRegistry:
|
|
"""Registry für alle verfügbaren Agenten im System"""
|
|
|
|
_instance = None
|
|
|
|
@classmethod
|
|
def get_instance(cls):
|
|
"""Gibt eine Singleton-Instanz der Agent-Registry zurück"""
|
|
if cls._instance is None:
|
|
cls._instance = cls()
|
|
return cls._instance
|
|
|
|
def __init__(self):
|
|
"""Initialisiert die Agent-Registry"""
|
|
if AgentRegistry._instance is not None:
|
|
raise RuntimeError("Singleton-Instanz existiert bereits - nutze get_instance()")
|
|
self.agents = {}
|
|
self._load_agents()
|
|
|
|
def _load_agents(self):
|
|
"""Lädt alle verfügbaren Agenten"""
|
|
# Liste aller zu ladenden Agenten-Module
|
|
agent_modules = [
|
|
"agentservice_agent_coder",
|
|
"agentservice_agent_analyst",
|
|
"agentservice_agent_webcrawler",
|
|
"agentservice_agent_sharepoint",
|
|
"agentservice_agent_documentation",
|
|
"agentservice_agent_filecreator" # Neuer FileCreator-Agent hinzugefügt
|
|
]
|
|
|
|
for module_name in agent_modules:
|
|
try:
|
|
# Importiere das Modul
|
|
try:
|
|
module = importlib.import_module(f"modules.{module_name}")
|
|
except ImportError:
|
|
module = importlib.import_module(module_name)
|
|
|
|
# Suche nach der Agent-Klasse oder einer get_*_agent-Funktion
|
|
agent_type = module_name.split('_')[-1]
|
|
class_name = f"{agent_type.capitalize()}Agent"
|
|
getter_name = f"get_{agent_type}_agent"
|
|
|
|
agent = None
|
|
|
|
# Versuche, den Agenten über die get_*_agent-Funktion zu holen
|
|
if hasattr(module, getter_name):
|
|
getter_func = getattr(module, getter_name)
|
|
agent = getter_func()
|
|
logger.info(f"Agent '{agent.name}' (Typ: {agent.type}) via {getter_name}() geladen")
|
|
|
|
# Alternativ versuche, den Agenten direkt zu instanziieren
|
|
elif hasattr(module, class_name):
|
|
agent_class = getattr(module, class_name)
|
|
agent = agent_class()
|
|
logger.info(f"Agent '{agent.name}' (Typ: {agent.type}) direkt instanziiert")
|
|
|
|
if agent:
|
|
# Registriere den Agenten
|
|
self.register_agent(agent)
|
|
else:
|
|
logger.warning(f"Keine Agent-Klasse oder getter-Funktion in Modul {module_name} gefunden")
|
|
|
|
except ImportError as e:
|
|
logger.warning(f"Modul {module_name} konnte nicht importiert werden: {e}")
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Laden des Agenten aus Modul {module_name}: {e}")
|
|
|
|
def register_agent(self, agent: BaseAgent):
|
|
"""Registriert einen Agenten in der Registry."""
|
|
agent_type = agent.type
|
|
self.agents[agent_type] = agent
|
|
# Zusätzlich nach ID registrieren
|
|
self.agents[agent.id] = agent
|
|
logger.debug(f"Agent '{agent.name}' (Typ: {agent_type}) wurde registriert")
|
|
|
|
def get_agent(self, agent_identifier: str) -> Optional[BaseAgent]:
|
|
"""
|
|
Gibt eine Instanz eines Agenten nach ID oder Typ zurück.
|
|
|
|
Args:
|
|
agent_identifier: ID oder Typ des gewünschten Agenten
|
|
|
|
Returns:
|
|
Agent-Instanz oder None, wenn nicht gefunden
|
|
"""
|
|
# Versuche, direkt nach Typ zu finden
|
|
if agent_identifier in self.agents:
|
|
return self.agents[agent_identifier]
|
|
|
|
# Wenn nicht gefunden, versuche verschiedene Varianten des Namens
|
|
variants = [
|
|
agent_identifier,
|
|
agent_identifier.replace('_agent', ''),
|
|
f"{agent_identifier}_agent"
|
|
]
|
|
|
|
for variant in variants:
|
|
if variant in self.agents:
|
|
return self.agents[variant]
|
|
|
|
logger.warning(f"Agent mit Identifier '{agent_identifier}' nicht gefunden")
|
|
return None
|
|
|
|
def get_all_agents(self) -> Dict[str, BaseAgent]:
|
|
"""Gibt alle registrierten Agenten zurück."""
|
|
return self.agents
|
|
|
|
def get_agent_infos(self) -> List[Dict[str, Any]]:
|
|
"""Gibt Informationen zu allen registrierten Agenten zurück."""
|
|
agent_infos = []
|
|
# Nur einmal pro Agent-Instanz (da wir sowohl nach Typ als auch nach ID registrieren)
|
|
seen_agents = set()
|
|
for agent in self.agents.values():
|
|
if agent not in seen_agents:
|
|
agent_infos.append(agent.get_agent_info())
|
|
seen_agents.add(agent)
|
|
return agent_infos
|
|
|
|
def initialize_agents_for_workflow(self) -> Dict[str, Dict[str, Any]]:
|
|
"""Initialisiert Agenten für einen Workflow."""
|
|
initialized_agents = {}
|
|
seen_agents = set()
|
|
for agent in self.agents.values():
|
|
if agent not in seen_agents:
|
|
agent_info = agent.get_agent_info()
|
|
agent_id = agent_info["id"]
|
|
initialized_agents[agent_id] = agent_info
|
|
seen_agents.add(agent)
|
|
return initialized_agents |