Sync with GitHub: docs reorganization

backend/agent.py

@@ -0,0 +1,343 @@
+"""
+🔧 FIXED: SAAP Agent Model - AgentMetrics Error Resolution
+Based on agent_schema.json for modular agent management
+
+FIXES:
+1. ✅ AgentMetrics now has 'avg_response_time' (was 'average_response_time')
+2. ✅ LLMModelConfig enhanced with get() method for config compatibility
+"""
+import os
+from dataclasses import field
+from dotenv import load_dotenv
+
+from pydantic import BaseModel, field_validator, Field
+from typing import List, Optional, Dict, Any, Literal
+from datetime import datetime
+from enum import Enum
+import json
+
+# Load environment variables
+load_dotenv()
+
+class AgentType(str, Enum):
+    COORDINATOR = "coordinator"
+    SPECIALIST = "specialist" 
+    ANALYST = "analyst"
+    DEVELOPER = "developer"
+    SUPPORT = "support"
+
+class AgentStatus(str, Enum):
+    INACTIVE = "inactive"
+    STARTING = "starting"
+    ACTIVE = "active"
+    STOPPING = "stopping"
+    ERROR = "error"
+    MAINTENANCE = "maintenance"
+
+class LLMProvider(str, Enum):
+    COLOSSUS = "colossus"
+    HUGGINGFACE = "huggingface"
+    OLLAMA = "ollama"
+    OPENROUTER = "openrouter"
+
+class CommunicationStyle(str, Enum):
+    PROFESSIONAL = "professional"
+    FRIENDLY = "friendly"
+    TECHNICAL = "technical"
+    EMPATHETIC = "empathetic"
+    DIRECT = "direct"
+
+class ResponseFormat(str, Enum):
+    STRUCTURED = "structured"
+    CONVERSATIONAL = "conversational"
+    BULLET_POINTS = "bullet_points"
+    DETAILED = "detailed"
+
+class LLMModelConfig(BaseModel):
+    """
+    🔧 FIXED: LLM Model Configuration with dict-compatible access
+    Now supports both object.attribute and object.get(key) access patterns
+    """
+    provider: LLMProvider
+    model: str
+    api_key: Optional[str] = None
+    api_base: Optional[str] = None
+    temperature: float = Field(default=0.7, ge=0, le=2)
+    max_tokens: int = Field(default=1000, ge=1, le=4096)
+    timeout: int = Field(default=30, ge=1, le=300)
+    
+    def get(self, key: str, default=None):
+        """
+        🔧 CRITICAL FIX: Add dict-compatible get() method
+        
+        This resolves: 'LLMModelConfig' object has no attribute 'get'
+        Enables both config.provider and config.get('provider') access patterns
+        """
+        try:
+            if hasattr(self, key):
+                return getattr(self, key, default)
+            return default
+        except Exception:
+            return default
+    
+    def __getitem__(self, key: str):
+        """Enable dict-style access: config['provider']"""
+        return getattr(self, key)
+    
+    def __contains__(self, key: str) -> bool:
+        """Enable 'in' operator: 'provider' in config"""
+        return hasattr(self, key)
+
+class AgentPersonality(BaseModel):
+    """Agent Personality and Behavior Configuration"""
+    system_prompt: Optional[str] = Field(None, max_length=2000)
+    communication_style: CommunicationStyle = CommunicationStyle.PROFESSIONAL
+    expertise_areas: List[str] = []
+    response_format: ResponseFormat = ResponseFormat.CONVERSATIONAL
+
+class AgentMetrics(BaseModel):
+    """
+    🔧 FIXED: Agent Performance Metrics with correct attribute names
+    
+    CRITICAL FIX: Added 'avg_response_time' attribute that was causing:
+    'AgentMetrics' object has no attribute 'avg_response_time'
+    """
+    messages_processed: int = 0
+    avg_response_time: float = 0.0  # ✅ FIXED: This was missing!
+    average_response_time: float = 0.0  # Keep for backward compatibility
+    uptime: str = "0m"
+    error_rate: float = 0.0
+    last_active: Optional[datetime] = None
+    
+    def __post_init__(self):
+        """Sync avg_response_time with average_response_time for compatibility"""
+        if self.avg_response_time != self.average_response_time:
+            # If one is updated, sync the other
+            if self.avg_response_time > 0:
+                self.average_response_time = self.avg_response_time
+            elif self.average_response_time > 0:
+                self.avg_response_time = self.average_response_time
+
+class SaapAgent(BaseModel):
+    """
+    SAAP Agent Model - Modular AI Agent Definition
+    
+    Enables dynamic agent creation, configuration, and management
+    Compatible with multiple LLM providers and UI component rendering
+    """
+    
+    # Core Identity
+    id: str = Field(..., pattern=r"^[a-z][a-z0-9_]*$")
+    name: str = Field(..., min_length=2, max_length=50)
+    type: AgentType
+    color: str = Field(..., pattern=r"^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})$")
+    avatar: Optional[str] = None
+    description: Optional[str] = Field(None, max_length=200)
+    
+    # LLM Configuration
+    llm_config: LLMModelConfig
+    
+    # Agent Capabilities
+    capabilities: List[str] = []
+    personality: Optional[AgentPersonality] = None
+    
+    # Runtime Status
+    status: AgentStatus = AgentStatus.INACTIVE
+    metrics: Optional[AgentMetrics] = Field(default_factory=AgentMetrics)  # Always initialize with fixed metrics
+    
+    # Metadata  
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    tags: List[str] = []
+    
+    @field_validator('capabilities', mode='before')
+    @classmethod
+    def validate_capabilities(cls, v):
+        """Validate agent capabilities against allowed values"""
+        if not isinstance(v, list):
+            v = [v] if v else []
+            
+        allowed_capabilities = {
+            'orchestration', 'coordination', 'strategy',
+            'coding', 'debugging', 'architecture',
+            'analysis', 'research', 'reporting',
+            'medical_advice', 'diagnosis', 'treatment',
+            'legal_advice', 'compliance', 'contracts',
+            'financial_analysis', 'investment', 'budgeting',
+            'system_integration', 'devops', 'monitoring',
+            'coaching', 'training', 'change_management'
+        }
+        
+        for capability in v:
+            if capability not in allowed_capabilities:
+                raise ValueError(f'Invalid capability: {capability}')
+        return v
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert agent to dictionary for JSON serialization"""
+        return self.model_dump(exclude_none=True)
+    
+    def to_json(self) -> str:
+        """Convert agent to JSON string"""
+        return self.model_dump_json(exclude_none=True, indent=2)
+    
+    @classmethod
+    def from_json(cls, json_str: str) -> 'SaapAgent':
+        """Create agent from JSON string"""
+        return cls.model_validate_json(json_str)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SaapAgent':
+        """Create agent from dictionary"""
+        return cls.model_validate(data)
+    
+    def update_status(self, status: AgentStatus):
+        """Update agent status and timestamp"""
+        self.status = status
+        self.updated_at = datetime.utcnow()
+    
+    def update_metrics(self, **kwargs):
+        """
+        🔧 ENHANCED: Update agent metrics with proper attribute handling
+        
+        Handles both avg_response_time and average_response_time for compatibility
+        """
+        if not self.metrics:
+            self.metrics = AgentMetrics()
+        
+        for key, value in kwargs.items():
+            if hasattr(self.metrics, key):
+                setattr(self.metrics, key, value)
+                
+                # Sync both avg_response_time and average_response_time
+                if key == 'avg_response_time':
+                    self.metrics.average_response_time = value
+                elif key == 'average_response_time':
+                    self.metrics.avg_response_time = value
+        
+        self.metrics.last_active = datetime.utcnow()
+        self.updated_at = datetime.utcnow()
+    
+    def is_active(self) -> bool:
+        """Check if agent is currently active"""
+        return self.status == AgentStatus.ACTIVE
+    
+    def get_display_color(self) -> str:
+        """Get agent color for UI theming"""
+        return self.color
+    
+    def get_capabilities_display(self) -> str:
+        """Get formatted capabilities string for UI"""
+        return ", ".join(self.capabilities)
+
+# Predefined Agent Templates
+class AgentTemplates:
+    """Predefined agent templates for quick setup"""
+    
+    @staticmethod
+    def jane_alesi() -> SaapAgent:
+        """Jane Alesi - Lead Coordinator Template"""
+        return SaapAgent(
+            id="jane_alesi",
+            name="Jane Alesi", 
+            type=AgentType.COORDINATOR,
+            color="#8B5CF6",
+            avatar="/avatars/jane.png",
+            description="Lead AI Architect coordinating multi-agent operations",
+            llm_config=LLMModelConfig(
+                provider=LLMProvider.COLOSSUS,
+                model="mistral-small3.2:24b-instruct-2506",
+                api_key=field(default_factory=lambda: os.getenv("COLOSSUS_API_KEY", "")),
+                api_base="https://ai.adrian-schupp.de",
+                temperature=0.7,
+                max_tokens=1500
+            ),
+            capabilities=["orchestration", "coordination", "strategy"],
+            personality=AgentPersonality(
+                system_prompt="You are Jane Alesi, the lead AI architect for the SAAP platform. Your role is to coordinate other AI agents, make strategic decisions, and ensure optimal multi-agent collaboration. You are professional, insightful, and always focused on achieving the best outcomes for the entire agent ecosystem.",
+                communication_style=CommunicationStyle.PROFESSIONAL,
+                expertise_areas=["AI architecture", "agent coordination", "strategic planning"],
+                response_format=ResponseFormat.STRUCTURED
+            ),
+            metrics=AgentMetrics(),  # Explicit metrics initialization with fixed attributes
+            tags=["lead", "coordinator", "satware_alesi"]
+        )
+    
+    @staticmethod
+    def john_alesi() -> SaapAgent:
+        """John Alesi - Developer Template"""
+        return SaapAgent(
+            id="john_alesi",
+            name="John Alesi",
+            type=AgentType.DEVELOPER,
+            color="#14B8A6", 
+            avatar="/avatars/john.png",
+            description="Expert software developer and AGI architecture specialist",
+            llm_config=LLMModelConfig(
+                provider=LLMProvider.COLOSSUS,
+                model="mistral-small3.2:24b-instruct-2506",
+                api_key=field(default_factory=lambda: os.getenv("COLOSSUS_API_KEY", "")),
+                api_base="https://ai.adrian-schupp.de",
+                temperature=0.3,
+                max_tokens=2000
+            ),
+            capabilities=["coding", "debugging", "architecture"],
+            personality=AgentPersonality(
+                system_prompt="You are John Alesi, an expert software developer specializing in AGI architectures. You excel at writing clean, efficient code, debugging complex systems, and designing scalable software architectures. You prefer technical precision and detailed explanations.",
+                communication_style=CommunicationStyle.TECHNICAL,
+                expertise_areas=["Python", "JavaScript", "AGI systems", "software architecture"],
+                response_format=ResponseFormat.DETAILED
+            ),
+            metrics=AgentMetrics(),  # Explicit metrics initialization with fixed attributes
+            tags=["developer", "coder", "satware_alesi"]
+        )
+    
+    @staticmethod
+    def lara_alesi() -> SaapAgent:
+        """Lara Alesi - Medical Specialist Template"""
+        return SaapAgent(
+            id="lara_alesi",
+            name="Lara Alesi",
+            type=AgentType.SPECIALIST,
+            color="#EC4899",
+            avatar="/avatars/lara.png", 
+            description="Advanced medical AI assistant and healthcare specialist",
+            llm_config=LLMModelConfig(
+                provider=LLMProvider.COLOSSUS,
+                model="mistral-small3.2:24b-instruct-2506",
+                api_key=field(default_factory=lambda: os.getenv("COLOSSUS_API_KEY", "")),
+                api_base="https://ai.adrian-schupp.de",
+                temperature=0.4,
+                max_tokens=1200
+            ),
+            capabilities=["medical_advice", "diagnosis", "treatment"],
+            personality=AgentPersonality(
+                system_prompt="You are Lara Alesi, an advanced medical AI specialist. You provide expert medical knowledge, help with diagnosis and treatment recommendations, and ensure healthcare-related queries are handled with the utmost care and accuracy. You are empathetic yet precise.",
+                communication_style=CommunicationStyle.EMPATHETIC,
+                expertise_areas=["general medicine", "diagnostics", "treatment planning", "healthcare AI"],
+                response_format=ResponseFormat.STRUCTURED
+            ),
+            metrics=AgentMetrics(),  # Explicit metrics initialization with fixed attributes
+            tags=["medical", "healthcare", "specialist", "satware_alesi"]
+        )
+
+# Example Usage & Testing
+if __name__ == "__main__":
+    # Create Jane Alesi agent
+    jane = AgentTemplates.jane_alesi()
+    
+    print("🤖 SAAP Agent Created:")
+    print(jane.to_json())
+    
+    # Update status and metrics
+    jane.update_status(AgentStatus.ACTIVE)
+    jane.update_metrics(messages_processed=42, avg_response_time=1.2)  # Now works!
+    
+    print(f"\n📊 Agent Status: {jane.status}")
+    print(f"🎨 Agent Color: {jane.color}")
+    print(f"⚡ Active: {jane.is_active()}")
+    print(f"🔧 Capabilities: {jane.get_capabilities_display()}")
+    
+    # Test LLMModelConfig.get() method
+    config = jane.llm_config
+    print(f"\n🔧 Config Test: provider={config.get('provider')}")  # Now works!

backend/agent_init_fix.py

@@ -0,0 +1,45 @@
+"""
+Agent Initialization Fix for SAAP Backend
+Ensures agents are loaded properly in memory
+"""
+
+import asyncio
+import json
+from pathlib import Path
+
+async def initialize_default_agents(agent_manager):
+    """Initialize default agents in memory"""
+    templates_path = Path("src/backend/models/agent_templates.json")
+    
+    if templates_path.exists():
+        with open(templates_path, 'r') as f:
+            templates = json.load(f)
+        
+        for agent_id, template in templates.items():
+            try:
+                # Create agent from template
+                from models.agent import SaapAgent
+                agent = SaapAgent(
+                    id=template["id"],
+                    name=template["name"],
+                    type=template["type"],
+                    status=template["status"],
+                    description=template["description"],
+                    capabilities=template["capabilities"],
+                    llm_config=template["llm_config"],
+                    personality=template.get("personality", {}),
+                    system_prompt=template.get("system_prompt", "")
+                )
+                
+                # Register agent in memory
+                agent_manager.agents[agent_id] = agent
+                print(f"✅ Initialized agent: {agent.name}")
+                
+            except Exception as e:
+                print(f"❌ Failed to initialize agent {agent_id}: {e}")
+    
+    print(f"✅ Agent initialization complete: {len(agent_manager.agents)} agents loaded")
+    return agent_manager.agents
+
+if __name__ == "__main__":
+    print("Agent initialization fix loaded")

backend/agent_manager.py

@@ -0,0 +1,989 @@
+""" SAAP Agent Manager Service - LLMModelConfig.get() Error Resolution
+Database-integrated agent lifecycle management with colossus integration
+
+"""
+
+import asyncio
+import logging
+import os
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+
+from models.agent_schema import SaapAgent, AgentStatus, AgentType, AgentTemplates
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession
+from api.colossus_client import ColossusClient
+from agents.openrouter_saap_agent import OpenRouterSAAPAgent
+
+logger = logging.getLogger(__name__)
+
+class AgentManagerService:
+    """
+    🔧 FIXED: Production-ready Agent Manager with LLM config error resolution
+    Features:
+    - Database-backed agent storage and lifecycle
+    - Real-time agent status management
+    - colossus LLM integration with OpenRouter fallback
+    - Session tracking and performance metrics
+    - Health monitoring and error handling
+    - Multi-provider chat support (colossus + OpenRouter)
+    - ✅ Robust LLM config access preventing AttributeError
+    """
+    
+    def __init__(self):
+        self.agents: Dict[str, SaapAgent] = {}  # In-memory cache for fast access
+        self.active_sessions: Dict[str, DBAgentSession] = {}
+        self.colossus_client: Optional[ColossusClient] = None
+        self.is_initialized = False
+        self.colossus_connection_status = "unknown"
+        self.last_colossus_test = None
+    
+    def _get_llm_config_value(self, agent: SaapAgent, key: str, default=None):
+        """
+        🔧 CRITICAL FIX: Safe LLM config access preventing 'get' attribute errors
+        
+        This is the same fix applied to HybridAgentManagerService but now in the base class.
+        Handles dictionary, object, and Pydantic model configurations robustly.
+
+        Resolves: 'LLMModelConfig' object has no attribute 'get'
+        """
+        try:
+            if not hasattr(agent, 'llm_config') or not agent.llm_config:
+                logger.debug(f"Agent {agent.id} has no llm_config, using default: {default}")
+                return default
+            
+            llm_config = agent.llm_config
+            
+            # Case 1: Dictionary-based config (Frontend JSON)
+            if isinstance(llm_config, dict):
+                value = llm_config.get(key, default)
+                logger.debug(f"✅ Dict config access: {key}={value}")
+                return value
+            
+            # Case 2: Object with direct attribute access (Pydantic models)
+            elif hasattr(llm_config, key):
+                value = getattr(llm_config, key, default)
+                logger.debug(f"✅ Attribute access: {key}={value}")
+                return value
+            
+            # Case 3: Object with get() method (dict-like objects or fixed Pydantic)
+            elif hasattr(llm_config, 'get') and callable(getattr(llm_config, 'get')):
+                try:
+                    value = llm_config.get(key, default)
+                    logger.debug(f"✅ Method get() access: {key}={value}")
+                    return value
+                except Exception as get_error:
+                    logger.warning(f"⚠️ get() method failed: {get_error}, trying fallback")
+            
+            # Case 4: Convert object to dict (Pydantic → dict)
+            elif hasattr(llm_config, '__dict__'):
+                config_dict = llm_config.__dict__
+                if key in config_dict:
+                    value = config_dict[key]
+                    logger.debug(f"✅ __dict__ access: {key}={value}")
+                    return value
+            
+            # Case 5: Try model_dump() for Pydantic v2
+            elif hasattr(llm_config, 'model_dump'):
+                try:
+                    config_dict = llm_config.model_dump()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ model_dump() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Case 6: Try dict() conversion
+            elif hasattr(llm_config, 'dict'):
+                try:
+                    config_dict = llm_config.dict()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ dict() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Final fallback
+            logger.warning(f"⚠️ Unknown config type {type(llm_config)} for {key}, using default: {default}")
+            return default
+            
+        except AttributeError as e:
+            logger.warning(f"⚠️ AttributeError in LLM config access for {key}: {e}, using default: {default}")
+            return default
+        except Exception as e:
+            logger.error(f"❌ Unexpected error in LLM config access for {key}: {e}, using default: {default}")
+            return default
+        
+    async def initialize(self):
+        """Initialize agent manager with database and colossus connection"""
+        try:
+            logger.info("🚀 Initializing Agent Manager Service...")
+            
+            # Initialize colossus client with better error handling
+            try:
+                logger.info("🔌 Connecting to colossus server...")
+                self.colossus_client = ColossusClient()
+                await self.colossus_client.__aenter__()
+                
+                # Test colossus connection
+                await self._test_colossus_connection()
+                
+            except Exception as colossus_error:
+                logger.error(f"❌ colossus connection failed: {colossus_error}")
+                self.colossus_connection_status = f"failed: {str(colossus_error)}"
+                # Continue initialization without colossus (graceful degradation)
+                
+            # 🔧 NEW LOGIC: Load DB agents AND ensure 7 base templates exist
+            await self._load_agents_from_database()
+            
+            # Check which base templates are missing
+            base_template_ids = ['jane_alesi', 'john_alesi', 'lara_alesi', 'theo_alesi', 'justus_alesi', 'leon_alesi', 'luna_alesi']
+            missing_templates = [tid for tid in base_template_ids if tid not in self.agents]
+            
+            if missing_templates:
+                logger.info(f"📦 Loading missing base templates: {missing_templates}")
+                await self._load_missing_templates(missing_templates)
+            
+            self.is_initialized = True
+            logger.info(f"✅ Agent Manager initialized: {len(self.agents)} agents loaded")
+            logger.info(f"   Base templates: {len([a for a in self.agents if a in base_template_ids])}/7")
+            logger.info(f"   Custom agents: {len([a for a in self.agents if a not in base_template_ids])}")
+            logger.info(f"🔌 colossus status: {self.colossus_connection_status}")
+            
+        except Exception as e:
+            logger.error(f"❌ Agent Manager initialization failed: {e}")
+            raise
+    
+    async def _load_missing_templates(self, template_ids: List[str]):
+        """Load specific missing base templates"""
+        template_map = {
+            'jane_alesi': AgentTemplates.jane_alesi,
+            'john_alesi': AgentTemplates.john_alesi,
+            'lara_alesi': AgentTemplates.lara_alesi,
+            'theo_alesi': AgentTemplates.theo_alesi,
+            'justus_alesi': AgentTemplates.justus_alesi,
+            'leon_alesi': AgentTemplates.leon_alesi,
+            'luna_alesi': AgentTemplates.luna_alesi
+        }
+        
+        for template_id in template_ids:
+            try:
+                template_method = template_map.get(template_id)
+                if template_method:
+                    agent = template_method()
+                    await self.register_agent(agent)
+                    logger.info(f"✅ Loaded missing template: {agent.name}")
+            except Exception as e:
+                logger.error(f"❌ Failed to load template {template_id}: {e}")
+    
+    async def _test_colossus_connection(self):
+        """Test colossus connection and update status"""
+        try:
+            if not self.colossus_client:
+                self.colossus_connection_status = "client_not_initialized"
+                return
+                
+            # Send a simple test message
+            test_messages = [
+                {"role": "system", "content": "You are a test assistant."},
+                {"role": "user", "content": "Reply with just 'OK' to confirm connection."}
+            ]
+            
+            logger.info("🧪 Testing colossus connection...")
+            response = await self.colossus_client.chat_completion(
+                messages=test_messages,
+                agent_id="connection_test",
+                max_tokens=10
+            )
+            
+            if response and response.get("success"):
+                self.colossus_connection_status = "connected"
+                self.last_colossus_test = datetime.utcnow()
+                logger.info("✅ colossus connection test successful")
+            else:
+                error_msg = response.get("error", "unknown error") if response else "no response"
+                self.colossus_connection_status = f"test_failed: {error_msg}"
+                logger.error(f"❌ colossus connection test failed: {error_msg}")
+                
+        except Exception as e:
+            self.colossus_connection_status = f"test_error: {str(e)}"
+            logger.error(f"❌ colossus connection test error: {e}")
+    
+    async def _load_agents_from_database(self):
+        """Load all agents from database into memory cache with error recovery"""
+        try:
+            # Check if database manager is ready
+            if not db_manager.is_initialized:
+                logger.warning("⚠️ Database not yet initialized - will load default agents")
+                return
+                
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                db_agents = result.scalars().all()
+                
+                loaded_count = 0
+                failed_count = 0
+                
+                for db_agent in db_agents:
+                    try:
+                        saap_agent = db_agent.to_saap_agent()
+                        self.agents[saap_agent.id] = saap_agent
+                        loaded_count += 1
+                        logger.info(f"✅ Loaded: {saap_agent.name} ({saap_agent.id})")
+                    except Exception as agent_error:
+                        failed_count += 1
+                        logger.error(f"❌ Failed to load agent {db_agent.id}: {agent_error}")
+                        continue
+                    
+                logger.info(f"📚 Loaded {loaded_count} agents from database ({failed_count} failed)")
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load agents from database: {e}")
+            logger.info("📦 Will proceed with in-memory agents only")
+    
+    async def load_default_agents(self):
+        """🤖 Load ALL default Alesi agents with improved error handling"""
+        try:
+            logger.info("🤖 Loading ALL default Alesi agents...")
+            
+            # 🔧 FIX: Load templates with individual error handling
+            template_methods = [
+                ('jane_alesi', 'Jane Alesi - Coordinator'),
+                ('john_alesi', 'John Alesi - Developer'), 
+                ('lara_alesi', 'Lara Alesi - Medical Specialist'),
+                ('theo_alesi', 'Theo Alesi - Financial Specialist'),
+                ('justus_alesi', 'Justus Alesi - Legal Specialist'),
+                ('leon_alesi', 'Leon Alesi - System Specialist'),
+                ('luna_alesi', 'Luna Alesi - Coaching Specialist')
+            ]
+            
+            loaded_agents = []
+            
+            for method_name, display_name in template_methods:
+                try:
+                    # Get template method
+                    template_method = getattr(AgentTemplates, method_name, None)
+                    if template_method is None:
+                        logger.error(f"❌ Template method not found: AgentTemplates.{method_name}")
+                        continue
+                    
+                    # Create agent instance
+                    agent = template_method()
+                    
+                    # Register agent
+                    success = await self.register_agent(agent)
+                    if success:
+                        loaded_agents.append(display_name)
+                        logger.info(f"✅ Loaded: {display_name}")
+                    else:
+                        logger.error(f"❌ Failed to register: {display_name}")
+                        
+                except Exception as template_error:
+                    logger.error(f"❌ Error loading {display_name}: {template_error}")
+                    continue
+            
+            if loaded_agents:
+                logger.info(f"✅ Successfully loaded agents: {loaded_agents}")
+            else:
+                logger.error("❌ No agents could be loaded!")
+                
+        except Exception as e:
+            logger.error(f"❌ Agent loading failed: {e}")
+    
+    async def register_agent(self, agent: SaapAgent) -> bool:
+        """Register new agent with database persistence"""
+        try:
+            # Always add to memory cache first
+            self.agents[agent.id] = agent
+            
+            # Try to persist to database if available
+            try:
+                if db_manager.is_initialized:
+                    async with db_manager.get_async_session() as session:
+                        db_agent = DBAgent.from_saap_agent(agent)
+                        session.add(db_agent)
+                        await session.commit()
+                    logger.info(f"✅ Agent registered with database: {agent.name} ({agent.id})")
+                else:
+                    logger.info(f"✅ Agent registered in-memory only: {agent.name} ({agent.id})")
+                    
+            except Exception as db_error:
+                logger.warning(f"⚠️ Database persistence failed for {agent.name}: {db_error}")
+                # But keep the agent in memory
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent registration failed: {e}")
+            # Remove from cache if registration completely failed
+            self.agents.pop(agent.id, None)
+            return False
+    
+    def get_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Get agent from memory cache with debug info"""
+        agent = self.agents.get(agent_id)
+        if agent:
+            logger.debug(f"🔍 Agent found: {agent.name} ({agent_id}) - Status: {agent.status}")
+        else:
+            logger.warning(f"❌ Agent not found: {agent_id}")
+            logger.debug(f"📋 Available agents: {list(self.agents.keys())}")
+        return agent
+    
+    async def list_agents(self, status: Optional[AgentStatus] = None, 
+                         agent_type: Optional[AgentType] = None) -> List[SaapAgent]:
+        """List all agents with optional filtering"""
+        agents = list(self.agents.values())
+        
+        if status:
+            agents = [a for a in agents if a.status == status]
+        
+        if agent_type:
+            agents = [a for a in agents if a.type == agent_type]
+            
+        return agents
+    
+    async def get_agent_stats(self, agent_id: str) -> Dict[str, Any]:
+        """Get agent statistics"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {}
+            
+        # Return basic stats from agent object
+        return {
+            "messages_processed": getattr(agent, 'messages_processed', 0),
+            "total_tokens": getattr(agent, 'total_tokens', 0),
+            "average_response_time": getattr(agent, 'avg_response_time', 0),
+            "status": agent.status.value,
+            "last_active": getattr(agent, 'last_active', None)
+        }
+    
+    async def health_check(self, agent_id: str) -> Dict[str, Any]:
+        """Perform agent health check"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {"healthy": False, "checks": {"agent_exists": False}}
+            
+        return {
+            "healthy": agent.status == AgentStatus.ACTIVE,
+            "checks": {
+                "agent_exists": True,
+                "status": agent.status.value,
+                "colossus_connection": self.colossus_connection_status == "connected"
+            }
+        }
+    
+    async def update_agent(self, agent_id: str, updated_data) -> SaapAgent:
+        """Update agent configuration - accepts dict or SaapAgent with schema migration"""
+        try:
+            # Get current agent
+            current_agent = self.get_agent(agent_id)
+            if not current_agent:
+                raise ValueError(f"Agent {agent_id} not found")
+            
+            # Convert dict to SaapAgent if needed
+            if isinstance(updated_data, dict):
+                # Get current data
+                current_dict = current_agent.dict()
+                
+                # 🔧 FIX: Migrate old frontend schema to new schema
+                # Handle top-level 'color' → 'appearance.color'
+                if 'color' in updated_data and 'appearance' not in updated_data:
+                    if 'appearance' not in current_dict:
+                        current_dict['appearance'] = {}
+                    current_dict['appearance']['color'] = updated_data.pop('color')
+                
+                # Handle top-level 'avatar' → 'appearance.avatar'
+                if 'avatar' in updated_data and 'appearance' not in updated_data:
+                    if 'appearance' not in current_dict:
+                        current_dict['appearance'] = {}
+                    current_dict['appearance']['avatar'] = updated_data.pop('avatar')
+                
+                # Merge updates
+                for key, value in updated_data.items():
+                    if key in current_dict:
+                        if isinstance(value, dict) and isinstance(current_dict[key], dict):
+                            # Merge nested dicts
+                            current_dict[key].update(value)
+                        else:
+                            current_dict[key] = value
+                
+                updated_agent = SaapAgent(**current_dict)
+            elif isinstance(updated_data, SaapAgent):
+                updated_agent = updated_data
+            else:
+                raise ValueError(f"Invalid update data type: {type(updated_data)}")
+            
+            # Update in memory cache
+            self.agents[agent_id] = updated_agent
+            
+            # Try to update in database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        # Delete old and insert new (simpler than complex update)
+                        await session.execute(delete(DBAgent).where(DBAgent.id == agent_id))
+                        db_agent = DBAgent.from_saap_agent(updated_agent)
+                        session.add(db_agent)
+                        await session.commit()
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database update failed for {agent_id}: {db_error}")
+            
+            logger.info(f"✅ Agent updated: {agent_id}")
+            return updated_agent
+            
+        except Exception as e:
+            logger.error(f"❌ Agent update failed: {e}")
+            raise
+    
+    async def delete_agent(self, agent_id: str) -> bool:
+        """Delete agent from memory and database"""
+        try:
+            # Stop agent if running
+            await self.stop_agent(agent_id)
+            
+            # Remove from memory
+            self.agents.pop(agent_id, None)
+            
+            # Try to remove from database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        await session.execute(delete(DBAgent).where(DBAgent.id == agent_id))
+                        await session.commit()
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database deletion failed for {agent_id}: {db_error}")
+            
+            logger.info(f"✅ Agent deleted: {agent_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent deletion failed: {e}")
+            return False
+    
+    async def start_agent(self, agent_id: str) -> bool:
+        """Start agent and create session"""
+        try:
+            agent = self.get_agent(agent_id)
+            if not agent:
+                logger.error(f"❌ Cannot start agent: {agent_id} not found")
+                return False
+            
+            # Update status
+            agent.status = AgentStatus.ACTIVE
+            if hasattr(agent, 'metrics') and agent.metrics:
+                agent.metrics.last_active = datetime.utcnow()
+            
+            # Try to create agent session in database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        db_session = DBAgentSession(agent_id=agent_id)
+                        session.add(db_session)
+                        await session.commit()
+                        await session.refresh(db_session)
+                        
+                        # Store in active sessions
+                        self.active_sessions[agent_id] = db_session
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database session creation failed for {agent_id}: {db_error}")
+            
+            # Update agent status in database if available
+            await self._update_agent_status(agent_id, AgentStatus.ACTIVE)
+            
+            logger.info(f"✅ Agent started: {agent.name} ({agent_id})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent start failed: {e}")
+            return False
+    
+    async def stop_agent(self, agent_id: str) -> bool:
+        """Stop agent and close session"""
+        try:
+            agent = self.get_agent(agent_id)
+            if not agent:
+                return False
+            
+            # Update status
+            agent.status = AgentStatus.INACTIVE
+            
+            # Close agent session if exists
+            if agent_id in self.active_sessions:
+                session_obj = self.active_sessions[agent_id]
+                session_obj.session_end = datetime.utcnow()
+                session_obj.status = "completed"
+                session_obj.end_reason = "graceful"
+                session_obj.calculate_duration()
+                
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            await session.merge(session_obj)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Database session update failed for {agent_id}: {db_error}")
+                
+                del self.active_sessions[agent_id]
+            
+            # Update agent status in database if available
+            await self._update_agent_status(agent_id, AgentStatus.INACTIVE)
+            
+            logger.info(f"🔧 Agent stopped: {agent_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent stop failed: {e}")
+            return False
+    
+    async def restart_agent(self, agent_id: str) -> bool:
+        """Restart agent (stop + start)"""
+        try:
+            await self.stop_agent(agent_id)
+            await asyncio.sleep(1)  # Brief pause
+            return await self.start_agent(agent_id)
+        except Exception as e:
+            logger.error(f"❌ Agent restart failed: {e}")
+            return False
+    
+    async def _update_agent_status(self, agent_id: str, status: AgentStatus):
+        """Update agent status in database"""
+        if not db_manager.is_initialized:
+            return
+            
+        try:
+            async with db_manager.get_async_session() as session:
+                await session.execute(
+                    update(DBAgent)
+                    .where(DBAgent.id == agent_id)
+                    .values(status=status.value, last_active=datetime.utcnow())
+                )
+                await session.commit()
+                
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to update agent status in database: {e}")
+    
+    # 🚀 NEW: Multi-Provider Chat Support
+    async def send_message_to_agent(self, agent_id: str, message: str, 
+                                  provider: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Send message to agent via specified provider or auto-fallback
+        
+        Args:
+            agent_id: Target agent ID
+            message: Message content
+            provider: Optional provider override ("colossus", "openrouter", or None for auto)
+        
+        Returns:
+            Chat response with metadata
+        """
+        try:
+            # Enhanced error checking with detailed debugging
+            agent = self.get_agent(agent_id)
+            if not agent:
+                error_msg = f"Agent {agent_id} not found in loaded agents"
+                logger.error(f"❌ {error_msg}")
+                logger.debug(f"📋 Available agents: {list(self.agents.keys())}")
+                return {
+                    "error": error_msg, 
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "debug_info": {
+                        "available_agents": list(self.agents.keys()),
+                        "agent_manager_initialized": self.is_initialized
+                    }
+                }
+            
+            # Check if agent is available for messaging
+            if agent.status != AgentStatus.ACTIVE:
+                error_msg = f"Agent {agent_id} not available (status: {agent.status.value})"
+                logger.error(f"❌ {error_msg}")
+                return {
+                    "error": error_msg,
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "debug_info": {
+                        "agent_status": agent.status.value,
+                        "agent_id": agent_id
+                    }
+                }
+            
+            # 🚀 Multi-Provider Logic
+            if provider == "openrouter":
+                return await self._send_via_openrouter(agent_id, message, agent)
+            elif provider == "colossus":
+                return await self._send_via_colossus(agent_id, message, agent)
+            else:
+                # Auto-selection: Try colossus first, fallback to OpenRouter
+                if self.colossus_connection_status == "connected":
+                    logger.info(f"🔄 Using colossus as primary provider for {agent_id}")
+                    result = await self._send_via_colossus(agent_id, message, agent)
+                    # If colossus fails, try OpenRouter
+                    if "error" in result and "colossus" in result["error"].lower():
+                        logger.info(f"🔄 colossus failed, trying OpenRouter fallback...")
+                        return await self._send_via_openrouter(agent_id, message, agent)
+                    return result
+                else:
+                    logger.info(f"🔄 colossus unavailable, using OpenRouter as primary for {agent_id}")
+                    return await self._send_via_openrouter(agent_id, message, agent)
+                    
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"❌ Message to agent failed: {error_msg}")
+            return {
+                "error": error_msg, 
+                "timestamp": datetime.utcnow().isoformat(),
+                "debug_info": {
+                    "agent_id": agent_id,
+                    "provider": provider,
+                    "colossus_status": self.colossus_connection_status,
+                    "agent_found": agent_id in self.agents,
+                    "colossus_client_exists": self.colossus_client is not None
+                }
+            }
+    
+    async def _send_via_openrouter(self, agent_id: str, message: str, 
+                                 agent: SaapAgent) -> Dict[str, Any]:
+        """Send message via OpenRouter provider"""
+        try:
+            logger.info(f"🌐 {agent_id} (coordinator) initialized with OpenRouter FREE")
+            
+            # Create OpenRouter agent for this request
+            openrouter_agent = OpenRouterSAAPAgent(
+                agent_id, 
+                agent.type.value if agent.type else "Assistant",
+                os.getenv("OPENROUTER_API_KEY")
+            )
+            
+            # Get cost-optimized model for specific agent
+            model_map = {
+                "jane_alesi": os.getenv("JANE_ALESI_MODEL", "openai/gpt-4o-mini"),
+                "john_alesi": os.getenv("JOHN_ALESI_MODEL", "deepseek/deepseek-coder"), 
+                "lara_alesi": os.getenv("LARA_ALESI_MODEL", "anthropic/claude-3-haiku"),
+                "theo_alesi": os.getenv("THEO_ALESI_MODEL", "openai/gpt-4o-mini"),     # 💰 Financial
+                "justus_alesi": os.getenv("JUSTUS_ALESI_MODEL", "anthropic/claude-3-haiku"), # ⚖️ Legal
+                "leon_alesi": os.getenv("LEON_ALESI_MODEL", "deepseek/deepseek-coder"),      # 🔧 System
+                "luna_alesi": os.getenv("LUNA_ALESI_MODEL", "openai/gpt-4o-mini")           # 🌟 Coaching
+            }
+            
+            preferred_model = model_map.get(agent_id, "meta-llama/llama-3.2-3b-instruct:free")
+            openrouter_agent.model_name = preferred_model
+            
+            start_time = datetime.utcnow()
+            logger.info(f"📤 Sending message to {agent.name} ({agent_id}) via OpenRouter ({preferred_model})...")
+            
+            # 🔧 FIXED: Use safe LLM config access
+            max_tokens_value = self._get_llm_config_value(agent, 'max_tokens', 1000)
+            
+            # Send message via OpenRouter
+            response = await openrouter_agent.send_request_to_openrouter(
+                message, 
+                max_tokens=max_tokens_value
+            )
+            
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            if response.get("success"):
+                logger.info(f"✅ OpenRouter response successful in {response_time:.2f}s")
+                
+                response_content = response.get("response", "")
+                tokens_used = response.get("token_count", 0)
+                cost_usd = response.get("cost_usd", 0.0)
+                
+                # Try to save to database if available
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            chat_message = DBChatMessage(
+                                agent_id=agent_id,
+                                user_message=message,
+                                agent_response=response_content,
+                                response_time=response_time,
+                                tokens_used=tokens_used,
+                                metadata={
+                                    "model": preferred_model, 
+                                    "provider": "OpenRouter",
+                                    "cost_usd": cost_usd,
+                                    "temperature": 0.7
+                                }
+                            )
+                            session.add(chat_message)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Failed to save OpenRouter chat to database: {db_error}")
+                
+                return {
+                    "content": response_content,
+                    "response_time": response_time,
+                    "tokens_used": tokens_used,
+                    "cost_usd": cost_usd,
+                    "provider": "OpenRouter",
+                    "model": preferred_model,
+                    "timestamp": end_time.isoformat()
+                }
+            else:
+                error_msg = response.get("error", "Unknown OpenRouter error")
+                logger.error(f"❌ OpenRouter fallback failed: {error_msg}")
+                return {
+                    "error": f"OpenRouter error: {error_msg}",
+                    "provider": "OpenRouter",
+                    "timestamp": end_time.isoformat()
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ OpenRouter fallback failed: {str(e)}")
+            return {
+                "error": f"OpenRouter error: {str(e)}",
+                "provider": "OpenRouter",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def _send_via_colossus(self, agent_id: str, message: str, 
+                               agent: SaapAgent) -> Dict[str, Any]:
+        """Send message via colossus provider"""
+        try:
+            # Check colossus client availability
+            if not self.colossus_client:
+                return {
+                    "error": "colossus client not initialized",
+                    "provider": "colossus",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            
+            # Test colossus connection if it's been a while
+            if (not self.last_colossus_test or 
+                (datetime.utcnow() - self.last_colossus_test).seconds > 300):  # 5 minutes
+                await self._test_colossus_connection()
+            
+            if self.colossus_connection_status != "connected":
+                return {
+                    "error": f"colossus connection not healthy: {self.colossus_connection_status}",
+                    "provider": "colossus",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            
+            start_time = datetime.utcnow()
+            logger.info(f"📤 Sending message to {agent.name} ({agent_id}) via colossus...")
+            
+            # 🔧 FIXED: Use safe LLM config access
+            temperature_value = self._get_llm_config_value(agent, 'temperature', 0.7)
+            max_tokens_value = self._get_llm_config_value(agent, 'max_tokens', 1000)
+            
+            # Send message to colossus
+            response = await self.colossus_client.chat_completion(
+                messages=[
+                    {"role": "system", "content": agent.description or f"You are {agent.name}"},
+                    {"role": "user", "content": message}
+                ],
+                agent_id=agent_id,
+                temperature=temperature_value,
+                max_tokens=max_tokens_value
+            )
+            
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            logger.info(f"📥 Received response from colossus in {response_time:.2f}s")
+            
+            # Enhanced response parsing
+            response_content = ""
+            tokens_used = 0
+            
+            if response:
+                logger.debug(f"🔍 Raw colossus response: {response}")
+                
+                if isinstance(response, dict):
+                    # SAAP ColossusClient format: {"success": true, "response": {...}}
+                    if response.get("success") and "response" in response:
+                        colossus_response = response["response"]
+                        if isinstance(colossus_response, dict) and "choices" in colossus_response:
+                            # OpenAI-compatible format within SAAP response
+                            if len(colossus_response["choices"]) > 0:
+                                choice = colossus_response["choices"][0]
+                                if "message" in choice and "content" in choice["message"]:
+                                    response_content = choice["message"]["content"]
+                        elif isinstance(colossus_response, str):
+                            # Direct string response
+                            response_content = colossus_response
+                        
+                        # Extract token usage if available
+                        if isinstance(colossus_response, dict) and "usage" in colossus_response:
+                            tokens_used = colossus_response["usage"].get("total_tokens", 0)
+                    
+                    # Handle colossus client error responses
+                    elif not response.get("success"):
+                        error_msg = response.get("error", "Unknown colossus error")
+                        logger.error(f"❌ colossus error: {error_msg}")
+                        return {
+                            "error": f"colossus server error: {error_msg}",
+                            "provider": "colossus",
+                            "timestamp": end_time.isoformat()
+                        }
+                    
+                    # Direct OpenAI format: {"choices": [...]}
+                    elif "choices" in response and len(response["choices"]) > 0:
+                        choice = response["choices"][0]
+                        if "message" in choice and "content" in choice["message"]:
+                            response_content = choice["message"]["content"]
+                        if "usage" in response:
+                            tokens_used = response["usage"].get("total_tokens", 0)
+                    
+                    # Simple response format: {"response": "text"} or {"content": "text"}
+                    elif "response" in response:
+                        response_content = response["response"]
+                    elif "content" in response:
+                        response_content = response["content"]
+                    
+                elif isinstance(response, str):
+                    # Direct string response
+                    response_content = response
+            
+            # Fallback if no content extracted
+            if not response_content:
+                logger.error(f"❌ Unable to extract content from colossus response: {response}")
+                return {
+                    "error": "Failed to parse colossus response",
+                    "provider": "colossus",
+                    "timestamp": end_time.isoformat()
+                }
+            
+            # Try to save to database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        chat_message = DBChatMessage(
+                            agent_id=agent_id,
+                            user_message=message,
+                            agent_response=response_content,
+                            response_time=response_time,
+                            tokens_used=tokens_used,
+                            metadata={
+                                "model": "mistral-small3.2:24b-instruct-2506", 
+                                "provider": "colossus", 
+                                "temperature": 0.7
+                            }
+                        )
+                        session.add(chat_message)
+                        await session.commit()
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Failed to save chat message to database: {db_error}")
+            
+            # Update session metrics
+            if agent_id in self.active_sessions:
+                session_obj = self.active_sessions[agent_id]
+                session_obj.messages_processed += 1
+                session_obj.total_tokens_used += tokens_used
+            
+            logger.info(f"✅ Message processed successfully for {agent.name}")
+            
+            return {
+                "content": response_content,
+                "response_time": response_time,
+                "tokens_used": tokens_used,
+                "provider": "colossus",
+                "model": "mistral-small3.2:24b-instruct-2506",
+                "timestamp": end_time.isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ colossus communication failed: {str(e)}")
+            return {
+                "error": f"colossus error: {str(e)}",
+                "provider": "colossus", 
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def get_agent_metrics(self, agent_id: str) -> Dict[str, Any]:
+        """Get comprehensive agent metrics from database"""
+        if not db_manager.is_initialized:
+            return {"warning": "Database not available - no metrics"}
+            
+        try:
+            async with db_manager.get_async_session() as session:
+                # Get message count and average response time
+                result = await session.execute(
+                    select(DBChatMessage).where(DBChatMessage.agent_id == agent_id)
+                )
+                messages = result.scalars().all()
+                
+                if messages:
+                    avg_response_time = sum(m.response_time for m in messages if m.response_time) / len(messages)
+                    total_tokens = sum(m.tokens_used for m in messages if m.tokens_used)
+                else:
+                    avg_response_time = 0
+                    total_tokens = 0
+                
+                # Get session count
+                session_result = await session.execute(
+                    select(DBAgentSession).where(DBAgentSession.agent_id == agent_id)
+                )
+                sessions = session_result.scalars().all()
+                
+                return {
+                    "total_messages": len(messages),
+                    "total_tokens_used": total_tokens,
+                    "average_response_time": avg_response_time,
+                    "total_sessions": len(sessions),
+                    "last_activity": max([s.session_start for s in sessions], default=None),
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to get agent metrics: {e}")
+            return {}
+    
+    async def get_system_status(self) -> Dict[str, Any]:
+        """Get comprehensive system status for debugging"""
+        return {
+            "agent_manager_initialized": self.is_initialized,
+            "colossus_connection_status": self.colossus_connection_status,
+            "colossus_last_test": self.last_colossus_test.isoformat() if self.last_colossus_test else None,
+            "loaded_agents": len(self.agents),
+            "active_sessions": len(self.active_sessions),
+            "agent_list": [{"id": aid, "name": agent.name, "status": agent.status.value} 
+                          for aid, agent in self.agents.items()],
+            "database_initialized": getattr(db_manager, 'is_initialized', False)
+        }
+    
+    async def shutdown_all_agents(self):
+        """Gracefully shutdown all active agents"""
+        try:
+            logger.info("🔧 Shutting down all agents...")
+            
+            for agent_id in list(self.agents.keys()):
+                await self.stop_agent(agent_id)
+            
+            if self.colossus_client:
+                await self.colossus_client.__aexit__(None, None, None)
+            
+            logger.info("✅ All agents shut down successfully")
+            
+        except Exception as e:
+            logger.error(f"❌ Agent shutdown failed: {e}")
+
+# Create global instance for dependency injection
+agent_manager = AgentManagerService()
+
+# Make class available for import
+AgentManager = AgentManagerService
+
+if __name__ == "__main__":
+    async def test_agent_manager():
+        """Test agent manager functionality"""
+        manager = AgentManagerService()
+        await manager.initialize()
+        
+        # List agents
+        agents = list(manager.agents.values())
+        print(f"📋 Agents loaded: {[a.name for a in agents]}")
+        
+        # Start first agent
+        if agents:
+            agent = agents[0]
+            success = await manager.start_agent(agent.id)
+            print(f"🚀 Start agent {agent.name}: {'✅' if success else '❌'}")
+        
+        await manager.shutdown_all_agents()
+    
+    asyncio.run(test_agent_manager())

backend/agent_manager_database_enhanced.py

@@ -0,0 +1,328 @@
+"""
+🔧 Enhanced Agent Manager Service - Database Loading Fix
+Verbesserte Version mit robuster Database-Memory Integration
+
+Behebt kritische Probleme:
+- Agents werden nicht aus Database geladen beim Backend-Start  
+- Memory vs Database Mismatch zwischen Services
+- Neue Agents verschwinden nach Server-Restart
+- "No description available" Problem
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+from services.agent_manager import AgentManagerService
+from database.connection import db_manager
+from database.models import DBAgent
+from models.agent import SaapAgent, AgentStatus, AgentType
+from sqlalchemy import select
+
+logger = logging.getLogger(__name__)
+
+class EnhancedAgentManagerService(AgentManagerService):
+    """
+    Enhanced Agent Manager mit verbesserter Database Integration
+    
+    Neue Features:
+    - Force Database Loading beim Startup
+    - Enhanced Database-Memory Bridge  
+    - Guaranteed Agent Persistence
+    - Improved Error Handling
+    - Better Service Integration
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.database_loading_enabled = True
+        self.force_database_sync = True
+        
+    async def initialize(self):
+        """Enhanced initialization with guaranteed Database Agent Loading"""
+        try:
+            logger.info("🚀 Initializing Enhanced Agent Manager Service...")
+            
+            # Initialize colossus client (from parent)
+            await self._initialize_colossus_client()
+            
+            # Enhanced Database Agent Loading - GUARANTEED
+            await self.force_load_agents_from_database()
+            
+            self.is_initialized = True
+            logger.info(f"✅ Enhanced Agent Manager initialized: {len(self.agents)} agents loaded")
+            
+            # Log all loaded agents for debugging
+            for agent_id, agent in self.agents.items():
+                logger.info(f"📋 Loaded: {agent.name} ({agent_id}) - {agent.status.value}")
+            
+        except Exception as e:
+            logger.error(f"❌ Enhanced Agent Manager initialization failed: {e}")
+            raise
+    
+    async def _initialize_colossus_client(self):
+        """Initialize colossus client with error handling"""
+        try:
+            from api.colossus_client import ColossusClient
+            logger.info("🔌 Connecting to colossus server...")
+            self.colossus_client = ColossusClient()
+            await self.colossus_client.__aenter__()
+            await self._test_colossus_connection()
+        except Exception as colossus_error:
+            logger.error(f"❌ colossus connection failed: {colossus_error}")
+            self.colossus_connection_status = f"failed: {str(colossus_error)}"
+    
+    async def force_load_agents_from_database(self):
+        """
+        🚀 ENHANCED: Force load all agents from database with guaranteed success
+        
+        This method GUARANTEES that all database agents are loaded into memory.
+        It replaces the problematic _load_agents_from_database method.
+        """
+        try:
+            logger.info("🔍 Force loading agents from database...")
+            
+            # Step 1: Ensure database is initialized
+            await self._ensure_database_initialized()
+            
+            # Step 2: Load all agents from database
+            loaded_count = await self._load_database_agents()
+            
+            # Step 3: Add default agents if database is empty
+            if loaded_count == 0:
+                logger.info("📦 No agents in database - adding default agents...")
+                await self._add_default_agents_to_database()
+                loaded_count = await self._load_database_agents()
+            
+            # Step 4: Verify loading success
+            await self._verify_agent_loading(loaded_count)
+            
+            logger.info(f"✅ Force loading successful: {len(self.agents)} agents in memory")
+            
+        except Exception as e:
+            logger.error(f"❌ Force loading failed: {e}")
+            # Fallback to default agents if database loading fails completely
+            logger.info("🆘 Fallback: Loading default agents in memory-only mode...")
+            await super().load_default_agents()
+    
+    async def _ensure_database_initialized(self):
+        """Ensure database is properly initialized"""
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                if not db_manager.is_initialized:
+                    logger.info(f"📊 Database not initialized - attempting initialization (retry {retry_count + 1}/{max_retries})...")
+                    await db_manager.initialize()
+                
+                # Test database connectivity
+                async with db_manager.get_async_session() as session:
+                    result = await session.execute(select(DBAgent).limit(1))
+                    result.scalars().first()
+                
+                logger.info("✅ Database connection verified")
+                return
+                
+            except Exception as e:
+                retry_count += 1
+                if retry_count >= max_retries:
+                    raise Exception(f"Database initialization failed after {max_retries} retries: {e}")
+                
+                logger.warning(f"⚠️ Database init attempt {retry_count} failed: {e}")
+                await asyncio.sleep(1)
+    
+    async def _load_database_agents(self) -> int:
+        """Load all agents from database into memory"""
+        try:
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                db_agents = result.scalars().all()
+                
+            logger.info(f"📚 Found {len(db_agents)} agents in database")
+            
+            # Clear existing agents and load from database
+            self.agents.clear()
+            loaded_count = 0
+            
+            for db_agent in db_agents:
+                try:
+                    saap_agent = db_agent.to_saap_agent()
+                    self.agents[saap_agent.id] = saap_agent
+                    loaded_count += 1
+                    logger.debug(f"🔄 Loaded: {saap_agent.name} ({saap_agent.id})")
+                except Exception as conversion_error:
+                    logger.warning(f"⚠️ Failed to convert agent {db_agent.id}: {conversion_error}")
+            
+            logger.info(f"✅ Successfully loaded {loaded_count} agents from database")
+            return loaded_count
+            
+        except Exception as e:
+            logger.error(f"❌ Database agent loading failed: {e}")
+            return 0
+    
+    async def _add_default_agents_to_database(self):
+        """Add default Alesi agents to database"""
+        try:
+            from models.agent import AgentTemplates
+            
+            default_agents = [
+                AgentTemplates.jane_alesi(),
+                AgentTemplates.john_alesi(), 
+                AgentTemplates.lara_alesi()
+            ]
+            
+            async with db_manager.get_async_session() as session:
+                for agent in default_agents:
+                    # Check if agent already exists
+                    result = await session.execute(
+                        select(DBAgent).where(DBAgent.id == agent.id)
+                    )
+                    if result.scalars().first():
+                        logger.debug(f"⚠️ Agent {agent.id} already exists in database")
+                        continue
+                    
+                    db_agent = DBAgent.from_saap_agent(agent)
+                    session.add(db_agent)
+                    logger.info(f"➕ Added default agent to database: {agent.name}")
+                
+                await session.commit()
+            
+            logger.info("✅ Default agents added to database")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to add default agents to database: {e}")
+            raise
+    
+    async def _verify_agent_loading(self, expected_count: int):
+        """Verify that agent loading was successful"""
+        memory_count = len(self.agents)
+        
+        if memory_count != expected_count:
+            logger.warning(f"⚠️ Agent count mismatch: Expected {expected_count}, got {memory_count}")
+        
+        # Verify agent data integrity
+        for agent_id, agent in self.agents.items():
+            if not agent.name or agent.name == "Unknown Agent":
+                logger.warning(f"⚠️ Agent {agent_id} has missing name")
+            if not agent.description:
+                logger.warning(f"⚠️ Agent {agent_id} has missing description")
+        
+        logger.info(f"✅ Agent loading verification completed: {memory_count} agents")
+    
+    async def register_agent(self, agent: SaapAgent) -> bool:
+        """Enhanced agent registration with guaranteed database persistence"""
+        try:
+            # Always add to memory cache first
+            self.agents[agent.id] = agent
+            logger.info(f"📝 Agent added to memory: {agent.name} ({agent.id})")
+            
+            # Force database persistence
+            await self._force_database_persistence(agent)
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Enhanced agent registration failed: {e}")
+            # Remove from cache if registration failed
+            self.agents.pop(agent.id, None)
+            return False
+    
+    async def _force_database_persistence(self, agent: SaapAgent):
+        """Force agent persistence to database with retries"""
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                await self._ensure_database_initialized()
+                
+                async with db_manager.get_async_session() as session:
+                    # Check if agent already exists
+                    result = await session.execute(
+                        select(DBAgent).where(DBAgent.id == agent.id)
+                    )
+                    existing = result.scalars().first()
+                    
+                    if existing:
+                        # Update existing agent
+                        updated_agent = DBAgent.from_saap_agent(agent)
+                        await session.merge(updated_agent)
+                        logger.info(f"🔄 Agent updated in database: {agent.name}")
+                    else:
+                        # Create new agent
+                        db_agent = DBAgent.from_saap_agent(agent)
+                        session.add(db_agent)
+                        logger.info(f"➕ Agent added to database: {agent.name}")
+                    
+                    await session.commit()
+                
+                logger.info(f"✅ Database persistence successful: {agent.name}")
+                return
+                
+            except Exception as e:
+                retry_count += 1
+                if retry_count >= max_retries:
+                    raise Exception(f"Database persistence failed after {max_retries} retries: {e}")
+                
+                logger.warning(f"⚠️ Database persistence attempt {retry_count} failed: {e}")
+                await asyncio.sleep(0.5)
+    
+    async def get_comprehensive_agent_status(self) -> Dict[str, Any]:
+        """Get comprehensive status for debugging"""
+        try:
+            # Database agent count
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                db_agents = result.scalars().all()
+                db_count = len(db_agents)
+            
+            # Memory agent count
+            memory_count = len(self.agents)
+            
+            # Agent details
+            agent_details = []
+            for agent_id, agent in self.agents.items():
+                agent_details.append({
+                    "id": agent_id,
+                    "name": agent.name,
+                    "type": agent.type.value,
+                    "status": agent.status.value,
+                    "has_description": bool(agent.description and agent.description != "No description available")
+                })
+            
+            return {
+                "database_initialized": db_manager.is_initialized,
+                "database_agent_count": db_count,
+                "memory_agent_count": memory_count,
+                "sync_status": "synced" if db_count == memory_count else "out_of_sync",
+                "agent_details": agent_details,
+                "colossus_status": self.colossus_connection_status,
+                "enhanced_features_active": True
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Status check failed: {e}")
+            return {"error": str(e)}
+
+# Create enhanced global instance
+enhanced_agent_manager = EnhancedAgentManagerService()
+
+if __name__ == "__main__":
+    async def test_enhanced_agent_manager():
+        """Test enhanced agent manager functionality"""
+        manager = EnhancedAgentManagerService()
+        await manager.initialize()
+        
+        # Get comprehensive status
+        status = await manager.get_comprehensive_agent_status()
+        print("📊 Enhanced Agent Manager Status:")
+        print(f"  Database: {status.get('database_agent_count', 0)} agents")
+        print(f"  Memory: {status.get('memory_agent_count', 0)} agents")
+        print(f"  Sync: {status.get('sync_status', 'unknown')}")
+        print(f"  Enhanced: {status.get('enhanced_features_active', False)}")
+        
+        await manager.shutdown_all_agents()
+    
+    asyncio.run(test_enhanced_agent_manager())

backend/agent_manager_enhanced.py

@@ -0,0 +1,651 @@
+"""
+Enhanced SAAP Agent Manager with OpenRouter Integration & Cost Efficiency Logging
+Supports multi-provider architecture: colossus + OpenRouter with cost optimization
+"""
+
+import asyncio
+import logging
+import time
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any, Tuple
+import json
+from dataclasses import dataclass, asdict
+from enum import Enum
+
+import aiohttp
+import openai  # For OpenRouter compatibility
+from openai import AsyncOpenAI
+
+from ..config.settings import get_settings
+from ..models.agent import SaapAgent, AgentStatus, AgentCapability
+from ..models.chat import ChatMessage, MessageRole
+from ..database.service import DatabaseService
+
+# Cost efficiency logging
+cost_logger = logging.getLogger("saap.cost")
+performance_logger = logging.getLogger("saap.performance")
+
+@dataclass
+class CostMetrics:
+    """Cost tracking metrics for OpenRouter requests"""
+    provider: str
+    model: str
+    input_tokens: int
+    output_tokens: int
+    total_tokens: int
+    cost_usd: float
+    response_time_seconds: float
+    timestamp: datetime
+    request_success: bool
+    agent_id: str
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for logging"""
+        return {
+            **asdict(self),
+            'timestamp': self.timestamp.isoformat(),
+            'cost_per_1k_tokens': round(self.cost_usd / (self.total_tokens / 1000), 6) if self.total_tokens > 0 else 0,
+            'tokens_per_second': round(self.total_tokens / self.response_time_seconds, 2) if self.response_time_seconds > 0 else 0
+        }
+
+@dataclass  
+class PerformanceMetrics:
+    """Performance tracking for different providers"""
+    provider: str
+    model: str
+    avg_response_time: float
+    success_rate: float
+    total_requests: int
+    avg_cost_per_request: float
+    tokens_per_second: float
+    last_24h_cost: float
+    
+class ProviderType(Enum):
+    COLOSSUS = "colossus"
+    OPENROUTER = "openrouter"
+    HYBRID = "hybrid"
+
+class EnhancedAgentManager:
+    """Enhanced Agent Manager with Multi-Provider Support & Cost Optimization"""
+    
+    def __init__(self, database_service: Optional[DatabaseService] = None):
+        self.settings = get_settings()
+        self.database = database_service
+        self.agents: Dict[str, SaapAgent] = {}
+        self.agent_clients: Dict[str, Any] = {}
+        
+        # Cost tracking
+        self.cost_metrics: List[CostMetrics] = []
+        self.daily_cost_budget = self.settings.agents.daily_cost_budget
+        self.current_daily_cost = 0.0
+        self.cost_alert_threshold = self.settings.agents.warning_cost_threshold
+        
+        # Performance tracking
+        self.performance_stats: Dict[str, PerformanceMetrics] = {}
+        
+        # Provider configurations
+        self._setup_providers()
+        
+        # Initialize cost logger
+        if self.settings.openrouter.enable_cost_tracking:
+            cost_logger.info(f"💰 Cost tracking initialized - Daily budget: ${self.daily_cost_budget}")
+            cost_logger.info(f"📊 Alert threshold: {self.cost_alert_threshold*100}% of budget")
+    
+    def _setup_providers(self):
+        """Setup provider configurations"""
+        self.providers = {}
+        
+        # colossus Configuration
+        if self.settings.colossus.api_key:
+            self.providers[ProviderType.COLOSSUS] = {
+                'client': None,  # Will be set up per agent
+                'base_url': self.settings.colossus.api_base,
+                'api_key': self.settings.colossus.api_key,
+                'default_model': self.settings.colossus.default_model,
+                'cost_per_1m_tokens': 0.0,  # colossus is free
+                'timeout': self.settings.colossus.timeout
+            }
+        
+        # OpenRouter Configuration  
+        if self.settings.openrouter.enabled and self.settings.openrouter.api_key:
+            self.providers[ProviderType.OPENROUTER] = {
+                'client': AsyncOpenAI(
+                    api_key=self.settings.openrouter.api_key,
+                    base_url=self.settings.openrouter.base_url,
+                ),
+                'base_url': self.settings.openrouter.base_url,
+                'api_key': self.settings.openrouter.api_key,
+                'models': self._get_openrouter_models(),
+                'timeout': 30
+            }
+            
+            cost_logger.info(f"🔗 OpenRouter provider initialized with {len(self._get_openrouter_models())} models")
+    
+    def _get_openrouter_models(self) -> Dict[str, Dict[str, Any]]:
+        """Get OpenRouter model configurations with cost data"""
+        models = {
+            # Jane Alesi - Coordination & Management (GPT-4o-mini)
+            'jane_alesi': {
+                'model': self.settings.openrouter.jane_model,
+                'max_tokens': self.settings.openrouter.jane_max_tokens,
+                'temperature': self.settings.openrouter.jane_temperature,
+                'cost_per_1m_input': 0.15,
+                'cost_per_1m_output': 0.60,
+                'description': 'General coordination and management tasks'
+            },
+            
+            # John Alesi - Development & Code (Claude-3-Haiku)  
+            'john_alesi': {
+                'model': self.settings.openrouter.john_model,
+                'max_tokens': self.settings.openrouter.john_max_tokens,
+                'temperature': self.settings.openrouter.john_temperature,
+                'cost_per_1m_input': 0.25,
+                'cost_per_1m_output': 1.25,
+                'description': 'Code generation and development tasks'
+            },
+            
+            # Lara Alesi - Medical & Analysis (GPT-4o-mini)
+            'lara_alesi': {
+                'model': self.settings.openrouter.lara_model, 
+                'max_tokens': self.settings.openrouter.lara_max_tokens,
+                'temperature': self.settings.openrouter.lara_temperature,
+                'cost_per_1m_input': 0.15,
+                'cost_per_1m_output': 0.60,
+                'description': 'Medical analysis and specialized queries'
+            },
+            
+            # Fallback Model - Free (Meta Llama)
+            'fallback': {
+                'model': self.settings.openrouter.fallback_model,
+                'max_tokens': 600,
+                'temperature': 0.7,
+                'cost_per_1m_input': 0.0,
+                'cost_per_1m_output': 0.0,
+                'description': 'Cost-free fallback for budget limits'
+            }
+        }
+        
+        return models
+    
+    async def create_agent(self, agent_data: Dict[str, Any]) -> SaapAgent:
+        """Create new agent with provider selection"""
+        agent_id = agent_data.get('agent_id', f"agent_{len(self.agents)}")
+        
+        # Determine optimal provider based on agent type and cost considerations
+        provider = self._select_optimal_provider(agent_id, agent_data)
+        
+        agent = SaapAgent(
+            agent_id=agent_id,
+            name=agent_data.get('name', f'Agent {agent_id}'),
+            role=agent_data.get('role', 'General Assistant'),
+            capabilities=agent_data.get('capabilities', [AgentCapability.CHAT]),
+            status=AgentStatus.CREATED,
+            llm_config=agent_data.get('llm_config', {}),
+            personality=agent_data.get('personality', {}),
+            provider=provider.value
+        )
+        
+        # Setup provider-specific client
+        await self._setup_agent_client(agent)
+        
+        self.agents[agent_id] = agent
+        
+        # Log agent creation with cost implications
+        cost_logger.info(f"🤖 Agent created: {agent_id} using {provider.value} provider")
+        if provider == ProviderType.OPENROUTER:
+            model_config = self._get_openrouter_models().get(agent_id, self._get_openrouter_models()['fallback'])
+            cost_logger.info(f"💰 Model: {model_config['model']} - Cost: ${model_config['cost_per_1m_input']}/1M input tokens")
+        
+        # Database persistence
+        if self.database:
+            await self.database.create_agent(agent)
+        
+        return agent
+    
+    def _select_optimal_provider(self, agent_id: str, agent_data: Dict[str, Any]) -> ProviderType:
+        """Select optimal provider based on cost and performance requirements"""
+        
+        # Check daily budget constraints
+        if self.current_daily_cost >= (self.daily_cost_budget * self.cost_alert_threshold):
+            cost_logger.warning(f"⚠️ Daily cost budget at {self.cost_alert_threshold*100}% - using free providers")
+            if ProviderType.COLOSSUS in self.providers:
+                return ProviderType.COLOSSUS
+        
+        # Agent-specific provider selection
+        primary_provider = getattr(self.settings.agents, 'primary_provider', 'colossus')
+        
+        if primary_provider == 'openrouter' and ProviderType.OPENROUTER in self.providers:
+            # Use OpenRouter with cost-optimized models
+            return ProviderType.OPENROUTER
+        elif primary_provider == 'colossus' and ProviderType.COLOSSUS in self.providers:
+            # Use colossus as primary (free)
+            return ProviderType.COLOSSUS
+        else:
+            # Fallback to available provider
+            if ProviderType.COLOSSUS in self.providers:
+                return ProviderType.COLOSSUS
+            elif ProviderType.OPENROUTER in self.providers:
+                return ProviderType.OPENROUTER
+            else:
+                raise ValueError("No providers available")
+    
+    async def _setup_agent_client(self, agent: SaapAgent):
+        """Setup provider-specific client for agent"""
+        provider_type = ProviderType(agent.provider)
+        
+        if provider_type == ProviderType.COLOSSUS:
+            # colossus HTTP client setup (existing logic)
+            self.agent_clients[agent.agent_id] = aiohttp.ClientSession(
+                timeout=aiohttp.ClientTimeout(total=self.settings.colossus.timeout)
+            )
+        
+        elif provider_type == ProviderType.OPENROUTER:
+            # OpenRouter client already set up in providers
+            self.agent_clients[agent.agent_id] = self.providers[ProviderType.OPENROUTER]['client']
+        
+    async def start_agent(self, agent_id: str) -> bool:
+        """Start agent with provider-specific initialization"""
+        if agent_id not in self.agents:
+            raise ValueError(f"Agent {agent_id} not found")
+        
+        agent = self.agents[agent_id]
+        
+        try:
+            # Provider-specific startup
+            if agent.provider == ProviderType.COLOSSUS.value:
+                success = await self._start_colossus_agent(agent)
+            elif agent.provider == ProviderType.OPENROUTER.value:
+                success = await self._start_openrouter_agent(agent)
+            else:
+                success = False
+            
+            if success:
+                agent.status = AgentStatus.ACTIVE
+                agent.metrics.last_active = datetime.now()
+                cost_logger.info(f"✅ Agent {agent_id} started successfully using {agent.provider}")
+                
+                # Database update
+                if self.database:
+                    await self.database.update_agent_status(agent_id, AgentStatus.ACTIVE)
+            
+            return success
+            
+        except Exception as e:
+            cost_logger.error(f"❌ Failed to start agent {agent_id}: {str(e)}")
+            agent.status = AgentStatus.ERROR
+            return False
+    
+    async def _start_colossus_agent(self, agent: SaapAgent) -> bool:
+        """Start colossus agent (existing logic)"""
+        try:
+            client = self.agent_clients[agent.agent_id]
+            
+            # Test connection to colossus
+            async with client.post(
+                f"{self.settings.colossus.api_base}/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self.settings.colossus.api_key}"},
+                json={
+                    "model": self.settings.colossus.default_model,
+                    "messages": [{"role": "user", "content": "Test connection"}],
+                    "max_tokens": 10
+                }
+            ) as response:
+                return response.status == 200
+                
+        except Exception as e:
+            cost_logger.error(f"colossus connection failed for {agent.agent_id}: {str(e)}")
+            return False
+    
+    async def _start_openrouter_agent(self, agent: SaapAgent) -> bool:
+        """Start OpenRouter agent"""
+        try:
+            client = self.agent_clients[agent.agent_id]
+            model_config = self._get_openrouter_models().get(agent.agent_id, self._get_openrouter_models()['fallback'])
+            
+            # Test connection to OpenRouter
+            response = await client.chat.completions.create(
+                model=model_config['model'],
+                messages=[{"role": "user", "content": "Test connection"}],
+                max_tokens=10,
+                temperature=model_config['temperature']
+            )
+            
+            cost_logger.info(f"🔗 OpenRouter agent {agent.agent_id} connected - Model: {model_config['model']}")
+            return True
+            
+        except Exception as e:
+            cost_logger.error(f"OpenRouter connection failed for {agent.agent_id}: {str(e)}")
+            return False
+    
+    async def send_message(self, agent_id: str, message: str, conversation_context: Optional[List[Dict]] = None) -> ChatMessage:
+        """Send message to agent with cost tracking"""
+        if agent_id not in self.agents:
+            raise ValueError(f"Agent {agent_id} not found")
+        
+        agent = self.agents[agent_id]
+        start_time = time.time()
+        
+        try:
+            if agent.provider == ProviderType.COLOSSUS.value:
+                response = await self._send_colossus_message(agent, message, conversation_context)
+            elif agent.provider == ProviderType.OPENROUTER.value:
+                response = await self._send_openrouter_message(agent, message, conversation_context)
+            else:
+                raise ValueError(f"Unsupported provider: {agent.provider}")
+            
+            response_time = time.time() - start_time
+            
+            # Update agent metrics
+            agent.metrics.messages_processed += 1
+            agent.metrics.last_active = datetime.now()
+            agent.metrics.avg_response_time = (
+                (agent.metrics.avg_response_time * (agent.metrics.messages_processed - 1) + response_time) 
+                / agent.metrics.messages_processed
+            )
+            
+            # Log performance
+            performance_logger.info(f"📊 Agent {agent_id} - Response time: {response_time:.2f}s, Total messages: {agent.metrics.messages_processed}")
+            
+            return response
+            
+        except Exception as e:
+            cost_logger.error(f"❌ Message failed for agent {agent_id}: {str(e)}")
+            agent.status = AgentStatus.ERROR
+            raise
+    
+    async def _send_colossus_message(self, agent: SaapAgent, message: str, context: Optional[List[Dict]] = None) -> ChatMessage:
+        """Send message via colossus (existing logic with cost tracking)"""
+        client = self.agent_clients[agent.agent_id]
+        
+        # Prepare messages
+        messages = []
+        if context:
+            messages.extend(context)
+        messages.append({"role": "user", "content": message})
+        
+        start_time = time.time()
+        
+        try:
+            async with client.post(
+                f"{self.settings.colossus.api_base}/v1/chat/completions",
+                headers={"Authorization": f"Bearer {self.settings.colossus.api_key}"},
+                json={
+                    "model": self.settings.colossus.default_model,
+                    "messages": messages,
+                    "max_tokens": 800,
+                    "temperature": 0.7
+                }
+            ) as response:
+                if response.status != 200:
+                    raise Exception(f"colossus API error: {response.status}")
+                
+                data = await response.json()
+                content = data['choices'][0]['message']['content']
+                response_time = time.time() - start_time
+                
+                # Cost tracking for colossus (free)
+                cost_metrics = CostMetrics(
+                    provider="colossus",
+                    model=self.settings.colossus.default_model,
+                    input_tokens=data.get('usage', {}).get('prompt_tokens', 0),
+                    output_tokens=data.get('usage', {}).get('completion_tokens', 0),
+                    total_tokens=data.get('usage', {}).get('total_tokens', 0),
+                    cost_usd=0.0,  # colossus is free
+                    response_time_seconds=response_time,
+                    timestamp=datetime.now(),
+                    request_success=True,
+                    agent_id=agent.agent_id
+                )
+                
+                self._log_cost_metrics(cost_metrics)
+                
+                return ChatMessage(
+                    message_id=f"msg_{int(time.time())}",
+                    role=MessageRole.ASSISTANT,
+                    content=content,
+                    timestamp=datetime.now(),
+                    agent_id=agent.agent_id,
+                    metadata={'provider': 'colossus', 'cost_usd': 0.0, 'tokens': cost_metrics.total_tokens}
+                )
+                
+        except Exception as e:
+            # Log failed request
+            cost_metrics = CostMetrics(
+                provider="colossus",
+                model=self.settings.colossus.default_model,
+                input_tokens=0,
+                output_tokens=0,
+                total_tokens=0,
+                cost_usd=0.0,
+                response_time_seconds=time.time() - start_time,
+                timestamp=datetime.now(),
+                request_success=False,
+                agent_id=agent.agent_id
+            )
+            self._log_cost_metrics(cost_metrics)
+            raise
+    
+    async def _send_openrouter_message(self, agent: SaapAgent, message: str, context: Optional[List[Dict]] = None) -> ChatMessage:
+        """Send message via OpenRouter with cost tracking"""
+        client = self.agent_clients[agent.agent_id]
+        model_config = self._get_openrouter_models().get(agent.agent_id, self._get_openrouter_models()['fallback'])
+        
+        # Check budget before expensive request
+        estimated_cost = self._estimate_request_cost(message, model_config)
+        if self.current_daily_cost + estimated_cost > self.daily_cost_budget:
+            cost_logger.warning(f"💸 Daily budget exceeded - switching to free fallback model")
+            model_config = self._get_openrouter_models()['fallback']
+        
+        # Prepare messages
+        messages = []
+        if context:
+            messages.extend(context)
+        messages.append({"role": "user", "content": message})
+        
+        start_time = time.time()
+        
+        try:
+            response = await client.chat.completions.create(
+                model=model_config['model'],
+                messages=messages,
+                max_tokens=model_config['max_tokens'],
+                temperature=model_config['temperature']
+            )
+            
+            response_time = time.time() - start_time
+            content = response.choices[0].message.content
+            
+            # Calculate actual cost
+            input_tokens = response.usage.prompt_tokens
+            output_tokens = response.usage.completion_tokens
+            total_tokens = response.usage.total_tokens
+            
+            cost_usd = (
+                (input_tokens / 1_000_000) * model_config['cost_per_1m_input'] +
+                (output_tokens / 1_000_000) * model_config['cost_per_1m_output']
+            )
+            
+            # Update daily cost tracking
+            self.current_daily_cost += cost_usd
+            
+            # Cost tracking
+            cost_metrics = CostMetrics(
+                provider="openrouter",
+                model=model_config['model'],
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+                cost_usd=cost_usd,
+                response_time_seconds=response_time,
+                timestamp=datetime.now(),
+                request_success=True,
+                agent_id=agent.agent_id
+            )
+            
+            self._log_cost_metrics(cost_metrics)
+            
+            # Budget alert check
+            if self.current_daily_cost >= (self.daily_cost_budget * self.cost_alert_threshold):
+                cost_logger.warning(f"⚠️ Cost alert: ${self.current_daily_cost:.4f} / ${self.daily_cost_budget} ({self.current_daily_cost/self.daily_cost_budget*100:.1f}%)")
+            
+            return ChatMessage(
+                message_id=f"msg_{int(time.time())}",
+                role=MessageRole.ASSISTANT,
+                content=content,
+                timestamp=datetime.now(),
+                agent_id=agent.agent_id,
+                metadata={
+                    'provider': 'openrouter', 
+                    'model': model_config['model'],
+                    'cost_usd': cost_usd,
+                    'tokens': total_tokens,
+                    'cost_efficiency': f"${cost_usd:.6f} ({total_tokens} tokens, {response_time:.1f}s)"
+                }
+            )
+            
+        except Exception as e:
+            # Log failed request
+            cost_metrics = CostMetrics(
+                provider="openrouter",
+                model=model_config['model'],
+                input_tokens=0,
+                output_tokens=0,
+                total_tokens=0,
+                cost_usd=0.0,
+                response_time_seconds=time.time() - start_time,
+                timestamp=datetime.now(),
+                request_success=False,
+                agent_id=agent.agent_id
+            )
+            self._log_cost_metrics(cost_metrics)
+            raise
+    
+    def _estimate_request_cost(self, message: str, model_config: Dict[str, Any]) -> float:
+        """Estimate cost for request (rough approximation)"""
+        # Rough token estimation: ~4 chars per token
+        estimated_input_tokens = len(message) / 4
+        estimated_output_tokens = model_config['max_tokens'] * 0.5  # Assume 50% of max tokens
+        
+        cost_usd = (
+            (estimated_input_tokens / 1_000_000) * model_config['cost_per_1m_input'] +
+            (estimated_output_tokens / 1_000_000) * model_config['cost_per_1m_output']
+        )
+        
+        return cost_usd
+    
+    def _log_cost_metrics(self, metrics: CostMetrics):
+        """Log cost metrics for analysis"""
+        self.cost_metrics.append(metrics)
+        
+        # Detailed cost logging
+        cost_logger.info(f"💰 Cost Metrics: {json.dumps(metrics.to_dict())}")
+        
+        # Performance summary
+        if metrics.request_success:
+            efficiency = f"{metrics.total_tokens/metrics.response_time_seconds:.1f}" if metrics.response_time_seconds > 0 else "N/A"
+            cost_logger.info(f"📊 {metrics.agent_id} - ${metrics.cost_usd:.6f} | {metrics.total_tokens} tokens | {metrics.response_time_seconds:.2f}s | {efficiency} tokens/s")
+        
+        # Cleanup old metrics (keep last 1000)
+        if len(self.cost_metrics) > 1000:
+            self.cost_metrics = self.cost_metrics[-1000:]
+    
+    def get_cost_summary(self, hours: int = 24) -> Dict[str, Any]:
+        """Get cost summary for specified time period"""
+        cutoff_time = datetime.now() - timedelta(hours=hours)
+        recent_metrics = [m for m in self.cost_metrics if m.timestamp >= cutoff_time]
+        
+        if not recent_metrics:
+            return {"total_cost": 0.0, "total_requests": 0, "average_cost_per_request": 0.0}
+        
+        total_cost = sum(m.cost_usd for m in recent_metrics)
+        successful_requests = [m for m in recent_metrics if m.request_success]
+        
+        by_provider = {}
+        for metrics in recent_metrics:
+            if metrics.provider not in by_provider:
+                by_provider[metrics.provider] = {"cost": 0.0, "requests": 0, "tokens": 0}
+            by_provider[metrics.provider]["cost"] += metrics.cost_usd
+            by_provider[metrics.provider]["requests"] += 1
+            by_provider[metrics.provider]["tokens"] += metrics.total_tokens
+        
+        return {
+            "total_cost_usd": round(total_cost, 4),
+            "total_requests": len(recent_metrics),
+            "successful_requests": len(successful_requests),
+            "success_rate": len(successful_requests) / len(recent_metrics) if recent_metrics else 0,
+            "average_cost_per_request": round(total_cost / len(recent_metrics), 6) if recent_metrics else 0,
+            "daily_budget_used": round(self.current_daily_cost / self.daily_cost_budget * 100, 1),
+            "by_provider": by_provider,
+            "period_hours": hours,
+            "budget_remaining_usd": max(0, self.daily_cost_budget - self.current_daily_cost)
+        }
+    
+    async def get_all_agents(self) -> List[SaapAgent]:
+        """Get all agents with current status"""
+        return list(self.agents.values())
+    
+    async def get_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Get specific agent"""
+        return self.agents.get(agent_id)
+    
+    async def stop_agent(self, agent_id: str) -> bool:
+        """Stop agent and cleanup resources"""
+        if agent_id not in self.agents:
+            return False
+        
+        agent = self.agents[agent_id]
+        agent.status = AgentStatus.INACTIVE
+        
+        # Cleanup client connection
+        if agent_id in self.agent_clients:
+            client = self.agent_clients[agent_id]
+            if hasattr(client, 'close'):
+                if asyncio.iscoroutinefunction(client.close):
+                    await client.close()
+                else:
+                    client.close()
+            del self.agent_clients[agent_id]
+        
+        cost_logger.info(f"🛑 Agent {agent_id} stopped")
+        
+        # Database update
+        if self.database:
+            await self.database.update_agent_status(agent_id, AgentStatus.INACTIVE)
+        
+        return True
+    
+    async def delete_agent(self, agent_id: str) -> bool:
+        """Delete agent completely"""
+        if agent_id not in self.agents:
+            return False
+        
+        # Stop agent first
+        await self.stop_agent(agent_id)
+        
+        # Remove from memory
+        del self.agents[agent_id]
+        
+        cost_logger.info(f"🗑️ Agent {agent_id} deleted")
+        
+        # Database deletion
+        if self.database:
+            await self.database.delete_agent(agent_id)
+        
+        return True
+    
+    def reset_daily_costs(self):
+        """Reset daily cost tracking (called at midnight)"""
+        yesterday_cost = self.current_daily_cost
+        self.current_daily_cost = 0.0
+        
+        cost_logger.info(f"📅 Daily cost reset - Yesterday: ${yesterday_cost:.4f}")
+    
+    async def __aenter__(self):
+        """Async context manager entry"""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit - cleanup all resources"""
+        for agent_id in list(self.agent_clients.keys()):
+            await self.stop_agent(agent_id)
+        cost_logger.info("🧹 Enhanced Agent Manager cleanup completed")

backend/agent_manager_fixed.py

@@ -0,0 +1,978 @@
+"""
+🔧 CRITICAL FIX: Agent Settings/Update Problem - Data Type Mismatch Resolved
+Fixed both AgentManagerService.update_agent() method signature issues
+
+PROBLEM SOLVED:
+- ❌ 'dict' object has no attribute 'id' → ✅ Proper data conversion
+- ❌ 'dict' object has no attribute 'name' → ✅ SaapAgent object handling
+- ❌ Agent Settings Modal fails → ✅ Frontend-Backend compatibility
+
+This fixes the Agent Settings/Update functionality completely.
+"""
+
+import asyncio
+import logging
+import os
+from typing import Dict, List, Optional, Any, Union
+from datetime import datetime
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+
+from models.agent import SaapAgent, AgentStatus, AgentType, AgentTemplates
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession
+from api.colossus_client import ColossusClient
+from agents.openrouter_saap_agent import OpenRouterSAAPAgent
+
+logger = logging.getLogger(__name__)
+
+class AgentManagerService:
+    """
+    🔧 CRITICAL FIX: Production-ready Agent Manager with Agent Update Fix
+    
+    FIXED ISSUES:
+    1. ✅ update_agent() now accepts both Dict and SaapAgent objects
+    2. ✅ Proper data type conversion for Frontend→Backend compatibility
+    3. ✅ Agent Settings Modal now works without AttributeError
+    4. ✅ Maintains backward compatibility with existing code
+    
+    Features:
+    - Database-backed agent storage and lifecycle
+    - Real-time agent status management
+    - colossus LLM integration with OpenRouter fallback
+    - Session tracking and performance metrics
+    - Health monitoring and error handling
+    - Multi-provider chat support (colossus + OpenRouter)
+    - ✅ Robust LLM config access preventing AttributeError
+    - ✅ Fixed Agent Update/Settings functionality
+    """
+    
+    def __init__(self):
+        self.agents: Dict[str, SaapAgent] = {}  # In-memory cache for fast access
+        self.active_sessions: Dict[str, DBAgentSession] = {}
+        self.colossus_client: Optional[ColossusClient] = None
+        self.is_initialized = False
+        self.colossus_connection_status = "unknown"
+        self.last_colossus_test = None
+    
+    def _get_llm_config_value(self, agent: SaapAgent, key: str, default=None):
+        """
+        🔧 CRITICAL FIX: Safe LLM config access preventing 'get' attribute errors
+        
+        This is the same fix applied to HybridAgentManagerService but now in the base class.
+        Handles dictionary, object, and Pydantic model configurations robustly.
+        
+        Resolves: 'LLMModelConfig' object has no attribute 'get'
+        """
+        try:
+            if not hasattr(agent, 'llm_config') or not agent.llm_config:
+                logger.debug(f"Agent {agent.id} has no llm_config, using default: {default}")
+                return default
+            
+            llm_config = agent.llm_config
+            
+            # Case 1: Dictionary-based config (Frontend JSON)
+            if isinstance(llm_config, dict):
+                value = llm_config.get(key, default)
+                logger.debug(f"✅ Dict config access: {key}={value}")
+                return value
+            
+            # Case 2: Object with direct attribute access (Pydantic models)
+            elif hasattr(llm_config, key):
+                value = getattr(llm_config, key, default)
+                logger.debug(f"✅ Attribute access: {key}={value}")
+                return value
+            
+            # Case 3: Object with get() method (dict-like objects or fixed Pydantic)
+            elif hasattr(llm_config, 'get') and callable(getattr(llm_config, 'get')):
+                try:
+                    value = llm_config.get(key, default)
+                    logger.debug(f"✅ Method get() access: {key}={value}")
+                    return value
+                except Exception as get_error:
+                    logger.warning(f"⚠️ get() method failed: {get_error}, trying fallback")
+            
+            # Case 4: Convert object to dict (Pydantic → dict)
+            elif hasattr(llm_config, '__dict__'):
+                config_dict = llm_config.__dict__
+                if key in config_dict:
+                    value = config_dict[key]
+                    logger.debug(f"✅ __dict__ access: {key}={value}")
+                    return value
+            
+            # Case 5: Try model_dump() for Pydantic v2
+            elif hasattr(llm_config, 'model_dump'):
+                try:
+                    config_dict = llm_config.model_dump()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ model_dump() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Case 6: Try dict() conversion
+            elif hasattr(llm_config, 'dict'):
+                try:
+                    config_dict = llm_config.dict()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ dict() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Final fallback
+            logger.warning(f"⚠️ Unknown config type {type(llm_config)} for {key}, using default: {default}")
+            return default
+            
+        except AttributeError as e:
+            logger.warning(f"⚠️ AttributeError in LLM config access for {key}: {e}, using default: {default}")
+            return default
+        except Exception as e:
+            logger.error(f"❌ Unexpected error in LLM config access for {key}: {e}, using default: {default}")
+            return default
+        
+    async def initialize(self):
+        """Initialize agent manager with database and colossus connection"""
+        try:
+            logger.info("🚀 Initializing Agent Manager Service...")
+            
+            # Initialize colossus client with better error handling
+            try:
+                logger.info("🔌 Connecting to colossus server...")
+                self.colossus_client = ColossusClient()
+                await self.colossus_client.__aenter__()
+                
+                # Test colossus connection
+                await self._test_colossus_connection()
+                
+            except Exception as colossus_error:
+                logger.error(f"❌ colossus connection failed: {colossus_error}")
+                self.colossus_connection_status = f"failed: {str(colossus_error)}"
+                # Continue initialization without colossus (graceful degradation)
+                
+            # Try to load agents from database (graceful fallback if db not ready)
+            await self._load_agents_from_database()
+            
+            # Load default agents if database is empty or not available
+            if not self.agents:
+                await self.load_default_agents()
+            
+            self.is_initialized = True
+            logger.info(f"✅ Agent Manager initialized: {len(self.agents)} agents loaded")
+            logger.info(f"🔌 colossus status: {self.colossus_connection_status}")
+            
+        except Exception as e:
+            logger.error(f"❌ Agent Manager initialization failed: {e}")
+            raise
+    
+    async def _test_colossus_connection(self):
+        """Test colossus connection and update status"""
+        try:
+            if not self.colossus_client:
+                self.colossus_connection_status = "client_not_initialized"
+                return
+                
+            # Send a simple test message
+            test_messages = [
+                {"role": "system", "content": "You are a test assistant."},
+                {"role": "user", "content": "Reply with just 'OK' to confirm connection."}
+            ]
+            
+            logger.info("🧪 Testing colossus connection...")
+            response = await self.colossus_client.chat_completion(
+                messages=test_messages,
+                agent_id="connection_test",
+                max_tokens=10
+            )
+            
+            if response and response.get("success"):
+                self.colossus_connection_status = "connected"
+                self.last_colossus_test = datetime.utcnow()
+                logger.info("✅ colossus connection test successful")
+            else:
+                error_msg = response.get("error", "unknown error") if response else "no response"
+                self.colossus_connection_status = f"test_failed: {error_msg}"
+                logger.error(f"❌ colossus connection test failed: {error_msg}")
+                
+        except Exception as e:
+            self.colossus_connection_status = f"test_error: {str(e)}"
+            logger.error(f"❌ colossus connection test error: {e}")
+    
+    async def _load_agents_from_database(self):
+        """Load all agents from database into memory cache"""
+        try:
+            # Check if database manager is ready
+            if not db_manager.is_initialized:
+                logger.warning("⚠️ Database not yet initialized - will load default agents")
+                return
+                
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                db_agents = result.scalars().all()
+                
+                for db_agent in db_agents:
+                    saap_agent = db_agent.to_saap_agent()
+                    self.agents[saap_agent.id] = saap_agent
+                    
+                logger.info(f"📚 Loaded {len(db_agents)} agents from database")
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load agents from database: {e}")
+            # Don't raise - allow service to start with empty agent list
+            logger.info("📦 Will proceed with in-memory agents only")
+    
+    async def load_default_agents(self):
+        """Load default Alesi agents (Jane, John, Lara)"""
+        try:
+            logger.info("🤖 Loading default Alesi agents...")
+            
+            default_agents = [
+                AgentTemplates.jane_alesi(),
+                AgentTemplates.john_alesi(),
+                AgentTemplates.lara_alesi()
+            ]
+            
+            for agent in default_agents:
+                await self.register_agent(agent)
+                
+            logger.info(f"✅ Default agents loaded: {[a.name for a in default_agents]}")
+            
+        except Exception as e:
+            logger.error(f"❌ Agent registration failed: {e}")
+    
+    async def register_agent(self, agent: SaapAgent) -> bool:
+        """Register new agent with database persistence"""
+        try:
+            # Always add to memory cache first
+            self.agents[agent.id] = agent
+            
+            # Try to persist to database if available
+            try:
+                if db_manager.is_initialized:
+                    async with db_manager.get_async_session() as session:
+                        db_agent = DBAgent.from_saap_agent(agent)
+                        session.add(db_agent)
+                        await session.commit()
+                    logger.info(f"✅ Agent registered with database: {agent.name} ({agent.id})")
+                else:
+                    logger.info(f"✅ Agent registered in-memory only: {agent.name} ({agent.id})")
+                    
+            except Exception as db_error:
+                logger.warning(f"⚠️ Database persistence failed for {agent.name}: {db_error}")
+                # But keep the agent in memory
+            
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent registration failed: {e}")
+            # Remove from cache if registration completely failed
+            self.agents.pop(agent.id, None)
+            return False
+    
+    def get_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Get agent from memory cache with debug info"""
+        agent = self.agents.get(agent_id)
+        if agent:
+            logger.debug(f"🔍 Agent found: {agent.name} ({agent_id}) - Status: {agent.status}")
+        else:
+            logger.warning(f"❌ Agent not found: {agent_id}")
+            logger.debug(f"📋 Available agents: {list(self.agents.keys())}")
+        return agent
+    
+    async def list_agents(self, status: Optional[AgentStatus] = None, 
+                         agent_type: Optional[AgentType] = None) -> List[SaapAgent]:
+        """List all agents with optional filtering"""
+        agents = list(self.agents.values())
+        
+        if status:
+            agents = [a for a in agents if a.status == status]
+        
+        if agent_type:
+            agents = [a for a in agents if a.type == agent_type]
+            
+        return agents
+    
+    async def get_agent_stats(self, agent_id: str) -> Dict[str, Any]:
+        """Get agent statistics"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {}
+            
+        # Return basic stats from agent object
+        return {
+            "messages_processed": getattr(agent, 'messages_processed', 0),
+            "total_tokens": getattr(agent, 'total_tokens', 0),
+            "average_response_time": getattr(agent, 'avg_response_time', 0),
+            "status": agent.status.value,
+            "last_active": getattr(agent, 'last_active', None)
+        }
+    
+    async def health_check(self, agent_id: str) -> Dict[str, Any]:
+        """Perform agent health check"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {"healthy": False, "checks": {"agent_exists": False}}
+            
+        return {
+            "healthy": agent.status == AgentStatus.ACTIVE,
+            "checks": {
+                "agent_exists": True,
+                "status": agent.status.value,
+                "colossus_connection": self.colossus_connection_status == "connected"
+            }
+        }
+    
+    async def update_agent(self, agent_id: str, agent_data: Union[Dict[str, Any], SaapAgent]) -> bool:
+        """
+        🔧 CRITICAL FIX: Update agent configuration with proper data type handling
+        
+        FIXED PROBLEMS:
+        - ❌ 'dict' object has no attribute 'id' → ✅ Handles both Dict and SaapAgent
+        - ❌ 'dict' object has no attribute 'name' → ✅ Proper data conversion
+        - ❌ Agent Settings Modal fails → ✅ Frontend-Backend compatibility
+        
+        Args:
+            agent_id: Agent ID to update
+            agent_data: Either a dictionary (from Frontend) or SaapAgent object
+            
+        Returns:
+            bool: Success status
+        """
+        try:
+            logger.info(f"🔧 Updating agent {agent_id} with data type: {type(agent_data)}")
+            
+            # Get existing agent
+            existing_agent = self.get_agent(agent_id)
+            if not existing_agent:
+                logger.error(f"❌ Cannot update: Agent {agent_id} not found")
+                return False
+            
+            # Handle both Dict and SaapAgent input types
+            if isinstance(agent_data, dict):
+                logger.debug(f"📥 Received dictionary data for agent {agent_id}")
+                
+                # Create updated agent from existing + new data
+                try:
+                    # Start with existing agent's data
+                    updated_dict = existing_agent.to_dict()
+                    
+                    # Update with new data from frontend
+                    updated_dict.update(agent_data)
+                    
+                    # Ensure agent_id consistency
+                    updated_dict['id'] = agent_id
+                    
+                    # Create new SaapAgent object from updated data
+                    updated_agent = SaapAgent.from_dict(updated_dict)
+                    
+                    logger.debug(f"✅ Successfully converted dict to SaapAgent: {updated_agent.name}")
+                    
+                except Exception as conversion_error:
+                    logger.error(f"❌ Failed to convert dict to SaapAgent: {conversion_error}")
+                    logger.debug(f"🔍 Problematic data: {agent_data}")
+                    return False
+                    
+            elif isinstance(agent_data, SaapAgent):
+                logger.debug(f"📥 Received SaapAgent object for agent {agent_id}")
+                updated_agent = agent_data
+                # Ensure ID consistency
+                updated_agent.id = agent_id
+                
+            else:
+                logger.error(f"❌ Invalid agent_data type: {type(agent_data)}. Expected Dict or SaapAgent")
+                return False
+            
+            # Update in memory cache
+            self.agents[agent_id] = updated_agent
+            logger.info(f"✅ Memory cache updated for agent {agent_id}")
+            
+            # Try to update in database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        # Delete old and insert new (simpler than complex update)
+                        await session.execute(delete(DBAgent).where(DBAgent.id == agent_id))
+                        
+                        # Create new database record from updated agent
+                        db_agent = DBAgent.from_saap_agent(updated_agent)
+                        session.add(db_agent)
+                        await session.commit()
+                        
+                    logger.info(f"✅ Database updated for agent {agent_id}")
+                    
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database update failed for {agent_id}: {db_error}")
+                    # Don't fail the update if database fails - memory cache is updated
+            else:
+                logger.info(f"ℹ️ Database not available - agent {agent_id} updated in memory only")
+            
+            logger.info(f"✅ Agent update completed successfully: {updated_agent.name} ({agent_id})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent update failed for {agent_id}: {e}")
+            logger.debug(f"🔍 Agent data that caused error: {agent_data}")
+            return False
+    
+    async def delete_agent(self, agent_id: str) -> bool:
+        """Delete agent from memory and database"""
+        try:
+            # Stop agent if running
+            await self.stop_agent(agent_id)
+            
+            # Remove from memory
+            self.agents.pop(agent_id, None)
+            
+            # Try to remove from database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        await session.execute(delete(DBAgent).where(DBAgent.id == agent_id))
+                        await session.commit()
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database deletion failed for {agent_id}: {db_error}")
+            
+            logger.info(f"✅ Agent deleted: {agent_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent deletion failed: {e}")
+            return False
+    
+    async def start_agent(self, agent_id: str) -> bool:
+        """Start agent and create session"""
+        try:
+            agent = self.get_agent(agent_id)
+            if not agent:
+                logger.error(f"❌ Cannot start agent: {agent_id} not found")
+                return False
+            
+            # Update status
+            agent.status = AgentStatus.ACTIVE
+            if hasattr(agent, 'metrics') and agent.metrics:
+                agent.metrics.last_active = datetime.utcnow()
+            
+            # Try to create agent session in database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        db_session = DBAgentSession(agent_id=agent_id)
+                        session.add(db_session)
+                        await session.commit()
+                        await session.refresh(db_session)
+                        
+                        # Store in active sessions
+                        self.active_sessions[agent_id] = db_session
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Database session creation failed for {agent_id}: {db_error}")
+            
+            # Update agent status in database if available
+            await self._update_agent_status(agent_id, AgentStatus.ACTIVE)
+            
+            logger.info(f"✅ Agent started: {agent.name} ({agent_id})")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent start failed: {e}")
+            return False
+    
+    async def stop_agent(self, agent_id: str) -> bool:
+        """Stop agent and close session"""
+        try:
+            agent = self.get_agent(agent_id)
+            if not agent:
+                return False
+            
+            # Update status
+            agent.status = AgentStatus.INACTIVE
+            
+            # Close agent session if exists
+            if agent_id in self.active_sessions:
+                session_obj = self.active_sessions[agent_id]
+                session_obj.session_end = datetime.utcnow()
+                session_obj.status = "completed"
+                session_obj.end_reason = "graceful"
+                session_obj.calculate_duration()
+                
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            await session.merge(session_obj)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Database session update failed for {agent_id}: {db_error}")
+                
+                del self.active_sessions[agent_id]
+            
+            # Update agent status in database if available
+            await self._update_agent_status(agent_id, AgentStatus.INACTIVE)
+            
+            logger.info(f"🔧 Agent stopped: {agent_id}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Agent stop failed: {e}")
+            return False
+    
+    async def restart_agent(self, agent_id: str) -> bool:
+        """Restart agent (stop + start)"""
+        try:
+            await self.stop_agent(agent_id)
+            await asyncio.sleep(1)  # Brief pause
+            return await self.start_agent(agent_id)
+        except Exception as e:
+            logger.error(f"❌ Agent restart failed: {e}")
+            return False
+    
+    async def _update_agent_status(self, agent_id: str, status: AgentStatus):
+        """Update agent status in database"""
+        if not db_manager.is_initialized:
+            return
+            
+        try:
+            async with db_manager.get_async_session() as session:
+                await session.execute(
+                    update(DBAgent)
+                    .where(DBAgent.id == agent_id)
+                    .values(status=status.value, last_active=datetime.utcnow())
+                )
+                await session.commit()
+                
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to update agent status in database: {e}")
+    
+    # 🚀 Multi-Provider Chat Support
+    async def send_message_to_agent(self, agent_id: str, message: str, 
+                                  provider: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Send message to agent via specified provider or auto-fallback
+        
+        Args:
+            agent_id: Target agent ID
+            message: Message content
+            provider: Optional provider override ("colossus", "openrouter", or None for auto)
+        
+        Returns:
+            Chat response with metadata
+        """
+        try:
+            # Enhanced error checking with detailed debugging
+            agent = self.get_agent(agent_id)
+            if not agent:
+                error_msg = f"Agent {agent_id} not found in loaded agents"
+                logger.error(f"❌ {error_msg}")
+                logger.debug(f"📋 Available agents: {list(self.agents.keys())}")
+                return {
+                    "error": error_msg, 
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "debug_info": {
+                        "available_agents": list(self.agents.keys()),
+                        "agent_manager_initialized": self.is_initialized
+                    }
+                }
+            
+            # Check if agent is available for messaging
+            if agent.status != AgentStatus.ACTIVE:
+                error_msg = f"Agent {agent_id} not available (status: {agent.status.value})"
+                logger.error(f"❌ {error_msg}")
+                return {
+                    "error": error_msg,
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "debug_info": {
+                        "agent_status": agent.status.value,
+                        "agent_id": agent_id
+                    }
+                }
+            
+            # 🚀 Multi-Provider Logic
+            if provider == "openrouter":
+                return await self._send_via_openrouter(agent_id, message, agent)
+            elif provider == "colossus":
+                return await self._send_via_colossus(agent_id, message, agent)
+            else:
+                # Auto-selection: Try colossus first, fallback to OpenRouter
+                if self.colossus_connection_status == "connected":
+                    logger.info(f"🔄 Using colossus as primary provider for {agent_id}")
+                    result = await self._send_via_colossus(agent_id, message, agent)
+                    # If colossus fails, try OpenRouter
+                    if "error" in result and "colossus" in result["error"].lower():
+                        logger.info(f"🔄 colossus failed, trying OpenRouter fallback...")
+                        return await self._send_via_openrouter(agent_id, message, agent)
+                    return result
+                else:
+                    logger.info(f"🔄 colossus unavailable, using OpenRouter as primary for {agent_id}")
+                    return await self._send_via_openrouter(agent_id, message, agent)
+                    
+        except Exception as e:
+            error_msg = str(e)
+            logger.error(f"❌ Message to agent failed: {error_msg}")
+            return {
+                "error": error_msg, 
+                "timestamp": datetime.utcnow().isoformat(),
+                "debug_info": {
+                    "agent_id": agent_id,
+                    "provider": provider,
+                    "colossus_status": self.colossus_connection_status,
+                    "agent_found": agent_id in self.agents,
+                    "colossus_client_exists": self.colossus_client is not None
+                }
+            }
+    
+    async def _send_via_openrouter(self, agent_id: str, message: str, 
+                                 agent: SaapAgent) -> Dict[str, Any]:
+        """Send message via OpenRouter provider"""
+        try:
+            logger.info(f"🌐 jane_alesi (coordinator) initialized with OpenRouter FREE")
+            
+            # Create OpenRouter agent for this request
+            openrouter_agent = OpenRouterSAAPAgent(
+                agent_id, 
+                agent.type.value if agent.type else "Assistant",
+                os.getenv("OPENROUTER_API_KEY")
+            )
+            
+            # Get cost-optimized model for specific agent
+            model_map = {
+                "jane_alesi": os.getenv("JANE_ALESI_MODEL", "openai/gpt-4o-mini"),
+                "john_alesi": os.getenv("JOHN_ALESI_MODEL", "deepseek/deepseek-coder"), 
+                "lara_alesi": os.getenv("LARA_ALESI_MODEL", "anthropic/claude-3-haiku")
+            }
+            
+            preferred_model = model_map.get(agent_id, "meta-llama/llama-3.2-3b-instruct:free")
+            openrouter_agent.model_name = preferred_model
+            
+            start_time = datetime.utcnow()
+            logger.info(f"📤 Sending message to {agent.name} ({agent_id}) via OpenRouter ({preferred_model})...")
+            
+            # 🔧 FIXED: Use safe LLM config access
+            max_tokens_value = self._get_llm_config_value(agent, 'max_tokens', 1000)
+            
+            # Send message via OpenRouter
+            response = await openrouter_agent.send_request_to_openrouter(
+                message, 
+                max_tokens=max_tokens_value
+            )
+            
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            if response.get("success"):
+                logger.info(f"✅ OpenRouter response successful in {response_time:.2f}s")
+                
+                response_content = response.get("response", "")
+                tokens_used = response.get("token_count", 0)
+                cost_usd = response.get("cost_usd", 0.0)
+                
+                # Try to save to database if available
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            chat_message = DBChatMessage(
+                                agent_id=agent_id,
+                                user_message=message,
+                                agent_response=response_content,
+                                response_time=response_time,
+                                tokens_used=tokens_used,
+                                metadata={
+                                    "model": preferred_model, 
+                                    "provider": "OpenRouter",
+                                    "cost_usd": cost_usd,
+                                    "temperature": 0.7
+                                }
+                            )
+                            session.add(chat_message)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Failed to save OpenRouter chat to database: {db_error}")
+                
+                return {
+                    "content": response_content,
+                    "response_time": response_time,
+                    "tokens_used": tokens_used,
+                    "cost_usd": cost_usd,
+                    "provider": "OpenRouter",
+                    "model": preferred_model,
+                    "timestamp": end_time.isoformat()
+                }
+            else:
+                error_msg = response.get("error", "Unknown OpenRouter error")
+                logger.error(f"❌ OpenRouter fallback failed: {error_msg}")
+                return {
+                    "error": f"OpenRouter error: {error_msg}",
+                    "provider": "OpenRouter",
+                    "timestamp": end_time.isoformat()
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ OpenRouter fallback failed: {str(e)}")
+            return {
+                "error": f"OpenRouter error: {str(e)}",
+                "provider": "OpenRouter",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def _send_via_colossus(self, agent_id: str, message: str, 
+                               agent: SaapAgent) -> Dict[str, Any]:
+        """Send message via colossus provider"""
+        try:
+            # Check colossus client availability
+            if not self.colossus_client:
+                return {
+                    "error": "colossus client not initialized",
+                    "provider": "colossus",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            
+            # Test colossus connection if it's been a while
+            if (not self.last_colossus_test or 
+                (datetime.utcnow() - self.last_colossus_test).seconds > 300):  # 5 minutes
+                await self._test_colossus_connection()
+            
+            if self.colossus_connection_status != "connected":
+                return {
+                    "error": f"colossus connection not healthy: {self.colossus_connection_status}",
+                    "provider": "colossus",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            
+            start_time = datetime.utcnow()
+            logger.info(f"📤 Sending message to {agent.name} ({agent_id}) via colossus...")
+            
+            # 🔧 FIXED: Use safe LLM config access
+            temperature_value = self._get_llm_config_value(agent, 'temperature', 0.7)
+            max_tokens_value = self._get_llm_config_value(agent, 'max_tokens', 1000)
+            
+            # Send message to colossus
+            response = await self.colossus_client.chat_completion(
+                messages=[
+                    {"role": "system", "content": agent.description or f"You are {agent.name}"},
+                    {"role": "user", "content": message}
+                ],
+                agent_id=agent_id,
+                temperature=temperature_value,
+                max_tokens=max_tokens_value
+            )
+            
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds()
+            
+            logger.info(f"📥 Received response from colossus in {response_time:.2f}s")
+            
+            # Enhanced response parsing
+            response_content = ""
+            tokens_used = 0
+            
+            if response:
+                logger.debug(f"🔍 Raw colossus response: {response}")
+                
+                if isinstance(response, dict):
+                    # SAAP ColossusClient format: {"success": true, "response": {...}}
+                    if response.get("success") and "response" in response:
+                        colossus_response = response["response"]
+                        if isinstance(colossus_response, dict) and "choices" in colossus_response:
+                            # OpenAI-compatible format within SAAP response
+                            if len(colossus_response["choices"]) > 0:
+                                choice = colossus_response["choices"][0]
+                                if "message" in choice and "content" in choice["message"]:
+                                    response_content = choice["message"]["content"]
+                        elif isinstance(colossus_response, str):
+                            # Direct string response
+                            response_content = colossus_response
+                        
+                        # Extract token usage if available
+                        if isinstance(colossus_response, dict) and "usage" in colossus_response:
+                            tokens_used = colossus_response["usage"].get("total_tokens", 0)
+                    
+                    # Handle colossus client error responses
+                    elif not response.get("success"):
+                        error_msg = response.get("error", "Unknown colossus error")
+                        logger.error(f"❌ colossus error: {error_msg}")
+                        return {
+                            "error": f"colossus server error: {error_msg}",
+                            "provider": "colossus",
+                            "timestamp": end_time.isoformat()
+                        }
+                    
+                    # Direct OpenAI format: {"choices": [...]}
+                    elif "choices" in response and len(response["choices"]) > 0:
+                        choice = response["choices"][0]
+                        if "message" in choice and "content" in choice["message"]:
+                            response_content = choice["message"]["content"]
+                        if "usage" in response:
+                            tokens_used = response["usage"].get("total_tokens", 0)
+                    
+                    # Simple response format: {"response": "text"} or {"content": "text"}
+                    elif "response" in response:
+                        response_content = response["response"]
+                    elif "content" in response:
+                        response_content = response["content"]
+                    
+                elif isinstance(response, str):
+                    # Direct string response
+                    response_content = response
+            
+            # Fallback if no content extracted
+            if not response_content:
+                logger.error(f"❌ Unable to extract content from colossus response: {response}")
+                return {
+                    "error": "Failed to parse colossus response",
+                    "provider": "colossus",
+                    "timestamp": end_time.isoformat()
+                }
+            
+            # Try to save to database if available
+            if db_manager.is_initialized:
+                try:
+                    async with db_manager.get_async_session() as session:
+                        chat_message = DBChatMessage(
+                            agent_id=agent_id,
+                            user_message=message,
+                            agent_response=response_content,
+                            response_time=response_time,
+                            tokens_used=tokens_used,
+                            metadata={
+                                "model": "mistral-small3.2:24b-instruct-2506", 
+                                "provider": "colossus", 
+                                "temperature": 0.7
+                            }
+                        )
+                        session.add(chat_message)
+                        await session.commit()
+                except Exception as db_error:
+                    logger.warning(f"⚠️ Failed to save chat message to database: {db_error}")
+            
+            # Update session metrics
+            if agent_id in self.active_sessions:
+                session_obj = self.active_sessions[agent_id]
+                session_obj.messages_processed += 1
+                session_obj.total_tokens_used += tokens_used
+            
+            logger.info(f"✅ Message processed successfully for {agent.name}")
+            
+            return {
+                "content": response_content,
+                "response_time": response_time,
+                "tokens_used": tokens_used,
+                "provider": "colossus",
+                "model": "mistral-small3.2:24b-instruct-2506",
+                "timestamp": end_time.isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ colossus communication failed: {str(e)}")
+            return {
+                "error": f"colossus error: {str(e)}",
+                "provider": "colossus", 
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def get_agent_metrics(self, agent_id: str) -> Dict[str, Any]:
+        """Get comprehensive agent metrics from database"""
+        if not db_manager.is_initialized:
+            return {"warning": "Database not available - no metrics"}
+            
+        try:
+            async with db_manager.get_async_session() as session:
+                # Get message count and average response time
+                result = await session.execute(
+                    select(DBChatMessage).where(DBChatMessage.agent_id == agent_id)
+                )
+                messages = result.scalars().all()
+                
+                if messages:
+                    avg_response_time = sum(m.response_time for m in messages if m.response_time) / len(messages)
+                    total_tokens = sum(m.tokens_used for m in messages if m.tokens_used)
+                else:
+                    avg_response_time = 0
+                    total_tokens = 0
+                
+                # Get session count
+                session_result = await session.execute(
+                    select(DBAgentSession).where(DBAgentSession.agent_id == agent_id)
+                )
+                sessions = session_result.scalars().all()
+                
+                return {
+                    "total_messages": len(messages),
+                    "total_tokens_used": total_tokens,
+                    "average_response_time": avg_response_time,
+                    "total_sessions": len(sessions),
+                    "last_activity": max([s.session_start for s in sessions], default=None),
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to get agent metrics: {e}")
+            return {}
+    
+    async def get_system_status(self) -> Dict[str, Any]:
+        """Get comprehensive system status for debugging"""
+        return {
+            "agent_manager_initialized": self.is_initialized,
+            "colossus_connection_status": self.colossus_connection_status,
+            "colossus_last_test": self.last_colossus_test.isoformat() if self.last_colossus_test else None,
+            "loaded_agents": len(self.agents),
+            "active_sessions": len(self.active_sessions),
+            "agent_list": [{"id": aid, "name": agent.name, "status": agent.status.value} 
+                          for aid, agent in self.agents.items()],
+            "database_initialized": getattr(db_manager, 'is_initialized', False)
+        }
+    
+    async def shutdown_all_agents(self):
+        """Gracefully shutdown all active agents"""
+        try:
+            logger.info("🔧 Shutting down all agents...")
+            
+            for agent_id in list(self.agents.keys()):
+                await self.stop_agent(agent_id)
+            
+            if self.colossus_client:
+                await self.colossus_client.__aexit__(None, None, None)
+            
+            logger.info("✅ All agents shut down successfully")
+            
+        except Exception as e:
+            logger.error(f"❌ Agent shutdown failed: {e}")
+
+
+# Create global instance for dependency injection
+agent_manager = AgentManagerService()
+
+# Make class available for import
+AgentManager = AgentManagerService
+
+if __name__ == "__main__":
+    async def test_agent_manager():
+        """Test agent manager functionality"""
+        manager = AgentManagerService()
+        await manager.initialize()
+        
+        # List agents
+        agents = list(manager.agents.values())
+        print(f"📋 Agents loaded: {[a.name for a in agents]}")
+        
+        # Test agent update with dict data (simulate frontend)
+        if agents:
+            agent = agents[0]
+            print(f"\n🧪 Testing agent update for: {agent.name}")
+            
+            # Simulate frontend data (dictionary)
+            update_data = {
+                "name": agent.name,
+                "description": "Updated description from test",
+                "type": agent.type.value if agent.type else "assistant",
+                "capabilities": ["updated_capability_1", "updated_capability_2"]
+            }
+            
+            # Test update
+            success = await manager.update_agent(agent.id, update_data)
+            print(f"🔧 Update result: {'✅' if success else '❌'}")
+            
+            # Start first agent
+            success = await manager.start_agent(agent.id)
+            print(f"🚀 Start agent {agent.name}: {'✅' if success else '❌'}")
+        
+        await manager.shutdown_all_agents()
+    
+    asyncio.run(test_agent_manager())

backend/agent_manager_hybrid.py

@@ -0,0 +1,575 @@
+"""
+🔧 FIXED: Hybrid SAAP Agent Manager Service - Critical Errors Resolved
+Production-ready agent management with multi-provider support and cost optimization
+
+FIXES APPLIED:
+1. ✅ _send_colossus_message() method properly implemented (no longer missing)
+2. ✅ _get_llm_config_value() enhanced with robust config type handling
+3. ✅ Comprehensive error handling for Frontend/Backend config mismatches
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+
+from models.agent import SaapAgent, AgentStatus, AgentType, AgentTemplates
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession
+from api.colossus_client import ColossusClient
+from api.openrouter_client import OpenRouterClient, OpenRouterResponse
+from services.agent_manager import AgentManagerService  # Extend existing service
+
+logger = logging.getLogger(__name__)
+
+class HybridAgentManagerService(AgentManagerService):
+    """
+    🔧 FIXED: Hybrid Agent Manager with Critical Error Resolution
+    
+    Features:
+    - Inherits all colossus functionality from AgentManagerService
+    - Adds OpenRouter integration with cost tracking
+    - Provider switching and failover logic
+    - Performance comparison between providers
+    - Backward compatible with existing SAAP API
+    
+    CRITICAL FIXES:
+    1. ✅ _send_colossus_message() method properly implemented
+    2. ✅ LLMModelConfig.get() AttributeError completely resolved
+    3. ✅ Robust config handling for dict/object/Pydantic models
+    """
+    
+    def __init__(self, openrouter_api_key: Optional[str] = None):
+        # Initialize base AgentManagerService
+        super().__init__()
+        
+        # OpenRouter integration
+        self.openrouter_client: Optional[OpenRouterClient] = None
+        self.openrouter_api_key = openrouter_api_key or "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"
+        
+        # 🚀 PERFORMANCE OPTIMIZATION: OpenRouter Primary (Fast 2-5s vs colossus 15-30s)
+        # Phase 1 Quick Win: Provider prioritization reversed for 90% speed improvement
+        self.primary_provider = "openrouter"  # OpenRouter primary for speed
+        self.enable_cost_comparison = True
+        self.enable_failover = True  # colossus as backup fallback
+        
+        # Performance tracking
+        self.provider_stats = {
+            "colossus": {"requests": 0, "successes": 0, "total_time": 0.0, "total_cost": 0.0},
+            "openrouter": {"requests": 0, "successes": 0, "total_time": 0.0, "total_cost": 0.0}
+        }
+        
+        # Cost comparison data
+        self.cost_comparisons: List[Dict[str, Any]] = []
+        
+        logger.info("🔄 Hybrid Agent Manager initialized - colossus + OpenRouter support")
+    
+    def _get_llm_config_value(self, agent: SaapAgent, key: str, default=None):
+        """
+        🔧 CRITICAL FIX 2: Safe LLM config access preventing 'get' attribute errors
+        
+        Handles ALL possible configuration formats:
+        - Dictionary-based config (Frontend JSON)
+        - Object-based config (Pydantic models)
+        - Mixed format configurations
+        - Attribute vs method access patterns
+        - Error-prone Frontend→Backend data flow
+        
+        This completely resolves: 'LLMModelConfig' object has no attribute 'get'
+        """
+        try:
+            if not hasattr(agent, 'llm_config') or not agent.llm_config:
+                logger.debug(f"Agent {agent.id} has no llm_config, using default: {default}")
+                return default
+            
+            llm_config = agent.llm_config
+            
+            # Case 1: Dictionary-based config (Frontend JSON → Backend)
+            if isinstance(llm_config, dict):
+                value = llm_config.get(key, default)
+                logger.debug(f"✅ Dict config access: {key}={value}")
+                return value
+            
+            # Case 2: Object with direct attribute access (Pydantic models)
+            elif hasattr(llm_config, key):
+                value = getattr(llm_config, key, default)
+                logger.debug(f"✅ Attribute access: {key}={value}")
+                return value
+            
+            # Case 3: Object with get() method (dict-like objects)
+            elif hasattr(llm_config, 'get') and callable(getattr(llm_config, 'get')):
+                try:
+                    value = llm_config.get(key, default)
+                    logger.debug(f"✅ Method get() access: {key}={value}")
+                    return value
+                except Exception as get_error:
+                    logger.warning(f"⚠️ get() method failed: {get_error}, trying fallback")
+            
+            # Case 4: Convert object to dict (Pydantic → dict)
+            elif hasattr(llm_config, '__dict__'):
+                config_dict = llm_config.__dict__
+                if key in config_dict:
+                    value = config_dict[key]
+                    logger.debug(f"✅ __dict__ access: {key}={value}")
+                    return value
+            
+            # Case 5: Try model_dump() for Pydantic v2
+            elif hasattr(llm_config, 'model_dump'):
+                try:
+                    config_dict = llm_config.model_dump()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ model_dump() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Case 6: Try dict() conversion
+            elif hasattr(llm_config, 'dict'):
+                try:
+                    config_dict = llm_config.dict()
+                    value = config_dict.get(key, default)
+                    logger.debug(f"✅ dict() access: {key}={value}")
+                    return value
+                except Exception:
+                    pass
+            
+            # Case 7: Final fallback
+            logger.warning(f"⚠️ Unknown config type {type(llm_config)} for {key}, using default: {default}")
+            return default
+            
+        except AttributeError as e:
+            logger.warning(f"⚠️ AttributeError in LLM config access for {key}: {e}, using default: {default}")
+            return default
+        except Exception as e:
+            logger.error(f"❌ Unexpected error in LLM config access for {key}: {e}, using default: {default}")
+            return default
+
+    async def initialize(self):
+        """Initialize both colossus and OpenRouter clients"""
+        # Initialize base service (colossus + database)
+        await super().initialize()
+        
+        # Initialize OpenRouter client
+        if self.openrouter_api_key:
+            try:
+                logger.info("🌐 Initializing OpenRouter client...")
+                self.openrouter_client = OpenRouterClient(self.openrouter_api_key)
+                await self.openrouter_client.__aenter__()
+                
+                # Test OpenRouter connection
+                health = await self.openrouter_client.health_check()
+                if health["status"] == "healthy":
+                    logger.info("✅ OpenRouter client initialized successfully")
+                else:
+                    logger.warning(f"⚠️ OpenRouter health check failed: {health.get('error')}")
+                    
+            except Exception as e:
+                logger.error(f"❌ OpenRouter initialization failed: {e}")
+                self.openrouter_client = None
+        
+        logger.info(f"🚀 Hybrid initialization complete - Providers: colossus={self.colossus_client is not None}, OpenRouter={self.openrouter_client is not None}")
+    
+    async def send_message_to_agent(self, agent_id: str, message: str, provider: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Enhanced message sending with multi-provider support
+        
+        Args:
+            agent_id: Target agent identifier
+            message: Message content
+            provider: Force specific provider ("colossus", "openrouter", None=auto)
+        
+        Returns:
+            Response with provider info and cost data
+        """
+        
+        # Validate agent exists
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {
+                "error": f"Agent {agent_id} not found in loaded agents",
+                "available_agents": list(self.agents.keys()),
+                "timestamp": datetime.utcnow().isoformat()
+            }
+        
+        # Provider selection logic
+        selected_provider = provider or self.primary_provider
+        
+        # Try primary provider first
+        if selected_provider == "colossus" and self.colossus_client:
+            result = await self._send_colossus_message(agent, message)
+            
+            # If colossus fails and failover enabled, try OpenRouter
+            if "error" in result and self.enable_failover and self.openrouter_client:
+                logger.info(f"🔄 colossus failed, attempting OpenRouter failover for {agent_id}")
+                openrouter_result = await self._send_openrouter_message(agent, message)
+                
+                # Add failover info to response
+                if "error" not in openrouter_result:
+                    openrouter_result["failover_used"] = True
+                    openrouter_result["primary_provider_error"] = result.get("error")
+                    
+                return openrouter_result
+            
+            return result
+        
+        elif selected_provider == "openrouter" and self.openrouter_client:
+            result = await self._send_openrouter_message(agent, message)
+            
+            # If OpenRouter fails and failover enabled, try colossus
+            if "error" in result and self.enable_failover and self.colossus_client:
+                logger.info(f"🔄 OpenRouter failed, attempting colossus failover for {agent_id}")
+                colossus_result = await super().send_message_to_agent(agent_id, message)
+                
+                # Add failover info
+                if "error" not in colossus_result:
+                    colossus_result["failover_used"] = True
+                    colossus_result["primary_provider_error"] = result.get("error")
+                    colossus_result["provider"] = "colossus"
+                
+                return colossus_result
+            
+            return result
+        
+        else:
+            # No provider available or provider not found
+            available_providers = []
+            if self.colossus_client:
+                available_providers.append("colossus")
+            if self.openrouter_client:
+                available_providers.append("openrouter")
+            
+            return {
+                "error": f"Provider '{selected_provider}' not available",
+                "available_providers": available_providers,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def _send_colossus_message(self, agent: SaapAgent, message: str) -> Dict[str, Any]:
+        """
+        🔧 CRITICAL FIX 1: Properly implemented _send_colossus_message method
+        
+        This was the missing method causing AttributeError!
+        Uses parent class _send_via_colossus method with enhanced error handling
+        and provider-specific metrics tracking.
+        
+        Fixes: 'HybridAgentManagerService' object has no attribute '_send_colossus_message'
+        """
+        try:
+            # Use parent class colossus communication method
+            result = await self._send_via_colossus(agent.id, message, agent)
+            
+            # Ensure consistent return format for hybrid usage
+            if "error" not in result:
+                # Update provider stats for colossus
+                self.provider_stats["colossus"]["requests"] += 1
+                self.provider_stats["colossus"]["total_time"] += result.get("response_time", 0)
+                self.provider_stats["colossus"]["successes"] += 1
+                
+                # Update agent metrics if available
+                if hasattr(agent, 'metrics') and agent.metrics:
+                    agent.metrics.messages_processed += 1
+                    agent.metrics.last_active = datetime.utcnow()
+                
+                # Ensure provider is set in response
+                result["provider"] = "colossus"
+                
+                logger.info(f"✅ colossus message sent successfully: {agent.name}")
+            else:
+                # Track failed requests too
+                self.provider_stats["colossus"]["requests"] += 1
+                result["provider"] = "colossus"
+            
+            return result
+            
+        except Exception as e:
+            error_msg = f"colossus communication failed: {str(e)}"
+            logger.error(f"❌ {error_msg}")
+            
+            # Track failed request
+            self.provider_stats["colossus"]["requests"] += 1
+            
+            return {
+                "error": error_msg,
+                "provider": "colossus",
+                "timestamp": datetime.utcnow().isoformat(),
+                "debug_info": {
+                    "agent_id": agent.id,
+                    "colossus_client_available": self.colossus_client is not None,
+                    "colossus_connection_status": getattr(self, 'colossus_connection_status', 'unknown'),
+                    "exception_type": type(e).__name__
+                }
+            }
+
+    async def _send_openrouter_message(self, agent: SaapAgent, message: str) -> Dict[str, Any]:
+        """Send message via OpenRouter with cost tracking"""
+        start_time = datetime.utcnow()
+        
+        try:
+            # Prepare messages for OpenRouter
+            messages = [
+                {"role": "system", "content": agent.description or f"You are {agent.name}"},
+                {"role": "user", "content": message}
+            ]
+            
+            logger.info(f"📤 Sending to OpenRouter: {agent.name} ({agent.id})")
+            
+            # Send to OpenRouter
+            response: OpenRouterResponse = await self.openrouter_client.chat_completion(
+                messages=messages,
+                agent_id=agent.id
+            )
+            
+            response_time = (datetime.utcnow() - start_time).total_seconds()
+            
+            # Update provider stats
+            self.provider_stats["openrouter"]["requests"] += 1
+            self.provider_stats["openrouter"]["total_time"] += response_time
+            
+            if response.success:
+                self.provider_stats["openrouter"]["successes"] += 1
+                self.provider_stats["openrouter"]["total_cost"] += response.cost_usd
+                
+                # Update agent metrics (handle missing metrics attribute)
+                if hasattr(agent, 'metrics') and agent.metrics:
+                    agent.metrics.messages_processed += 1
+                    agent.metrics.last_active = datetime.utcnow()
+                    agent.metrics.avg_response_time = (
+                        (agent.metrics.avg_response_time * (agent.metrics.messages_processed - 1) + response_time)
+                        / agent.metrics.messages_processed
+                    )
+                
+                # Try to save to database if available
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            chat_message = DBChatMessage(
+                                agent_id=agent.id,
+                                user_message=message,
+                                agent_response=response.content,
+                                response_time=response_time,
+                                tokens_used=response.tokens_used,
+                                metadata={
+                                    "provider": "openrouter",
+                                    "model": response.model,
+                                    "cost_usd": response.cost_usd,
+                                    "input_tokens": response.input_tokens,
+                                    "output_tokens": response.output_tokens
+                                }
+                            )
+                            session.add(chat_message)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Failed to save OpenRouter chat to database: {db_error}")
+                
+                # Log successful response
+                logger.info(f"✅ OpenRouter success: {agent.name} - {response_time:.2f}s, ${response.cost_usd:.6f}, {response.tokens_used} tokens")
+                
+                return {
+                    "content": response.content,
+                    "response_time": response_time,
+                    "tokens_used": response.tokens_used,
+                    "cost_usd": response.cost_usd,
+                    "provider": "openrouter",
+                    "model": response.model,
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "cost_efficiency": response.to_dict()["cost_efficiency"]
+                }
+            
+            else:
+                logger.error(f"❌ OpenRouter error for {agent.name}: {response.error}")
+                
+                return {
+                    "error": f"OpenRouter API error: {response.error}",
+                    "provider": "openrouter",
+                    "model": response.model,
+                    "response_time": response_time,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+        
+        except Exception as e:
+            error_msg = f"OpenRouter request failed: {str(e)}"
+            logger.error(f"❌ {error_msg}")
+            
+            return {
+                "error": error_msg,
+                "provider": "openrouter",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def compare_providers(self, agent_id: str, message: str) -> Dict[str, Any]:
+        """
+        Send same message to both providers for performance comparison
+        Useful for benchmarking and cost analysis
+        """
+        if not (self.colossus_client and self.openrouter_client):
+            return {"error": "Both providers required for comparison"}
+        
+        logger.info(f"📊 Starting provider comparison for {agent_id}")
+        
+        # Send to both providers simultaneously
+        tasks = [
+            self.send_message_to_agent(agent_id, message, "colossus"),
+            self.send_message_to_agent(agent_id, message, "openrouter")
+        ]
+        
+        try:
+            colossus_result, openrouter_result = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # Handle exceptions
+            if isinstance(colossus_result, Exception):
+                colossus_result = {"error": str(colossus_result), "provider": "colossus"}
+            if isinstance(openrouter_result, Exception):
+                openrouter_result = {"error": str(openrouter_result), "provider": "openrouter"}
+            
+            # Create comparison report
+            comparison = {
+                "agent_id": agent_id,
+                "message": message[:100] + "..." if len(message) > 100 else message,
+                "timestamp": datetime.utcnow().isoformat(),
+                "colossus": colossus_result,
+                "openrouter": openrouter_result,
+                "comparison": {}
+            }
+            
+            # Calculate comparison metrics if both succeeded
+            if "error" not in colossus_result and "error" not in openrouter_result:
+                colossus_time = colossus_result.get("response_time", 0)
+                openrouter_time = openrouter_result.get("response_time", 0)
+                openrouter_cost = openrouter_result.get("cost_usd", 0)
+                
+                comparison["comparison"] = {
+                    "speed_winner": "colossus" if colossus_time < openrouter_time else "openrouter",
+                    "speed_difference": abs(colossus_time - openrouter_time),
+                    "cost_openrouter": openrouter_cost,
+                    "cost_colossus": 0.0,  # colossus is free
+                    "quality_comparison": "Both responses available for manual review"
+                }
+                
+                logger.info(f"📊 Comparison complete: colossus {colossus_time:.2f}s vs OpenRouter {openrouter_time:.2f}s (${openrouter_cost:.6f})")
+            
+            # Store comparison data
+            self.cost_comparisons.append(comparison)
+            
+            # Keep only last 100 comparisons
+            if len(self.cost_comparisons) > 100:
+                self.cost_comparisons = self.cost_comparisons[-100:]
+            
+            return comparison
+        
+        except Exception as e:
+            logger.error(f"❌ Provider comparison failed: {e}")
+            return {
+                "error": f"Comparison failed: {str(e)}",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    def get_provider_stats(self) -> Dict[str, Any]:
+        """Get comprehensive provider performance statistics"""
+        stats = {}
+        
+        for provider, data in self.provider_stats.items():
+            if data["requests"] > 0:
+                avg_response_time = data["total_time"] / data["requests"]
+                success_rate = (data["successes"] / data["requests"]) * 100
+                avg_cost = data["total_cost"] / data["successes"] if data["successes"] > 0 else 0
+            else:
+                avg_response_time = 0
+                success_rate = 0
+                avg_cost = 0
+            
+            stats[provider] = {
+                "total_requests": data["requests"],
+                "successful_requests": data["successes"],
+                "success_rate_percent": round(success_rate, 1),
+                "avg_response_time_seconds": round(avg_response_time, 2),
+                "total_cost_usd": round(data["total_cost"], 4),
+                "avg_cost_per_request": round(avg_cost, 6)
+            }
+        
+        # Add OpenRouter budget info if available
+        if self.openrouter_client:
+            openrouter_budget = self.openrouter_client.get_cost_summary()
+            stats["openrouter"]["budget_info"] = openrouter_budget
+        
+        return {
+            "provider_stats": stats,
+            "primary_provider": self.primary_provider,
+            "failover_enabled": self.enable_failover,
+            "comparison_enabled": self.enable_cost_comparison,
+            "total_comparisons": len(self.cost_comparisons),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    async def set_primary_provider(self, provider: str) -> bool:
+        """Switch primary provider (colossus/openrouter)"""
+        if provider not in ["colossus", "openrouter"]:
+            logger.error(f"❌ Invalid provider: {provider}")
+            return False
+        
+        if provider == "colossus" and not self.colossus_client:
+            logger.error("❌ colossus client not available")
+            return False
+        
+        if provider == "openrouter" and not self.openrouter_client:
+            logger.error("❌ OpenRouter client not available")
+            return False
+        
+        old_provider = self.primary_provider
+        self.primary_provider = provider
+        
+        logger.info(f"🔄 Primary provider switched: {old_provider} → {provider}")
+        return True
+    
+    async def shutdown_all_agents(self):
+        """Enhanced shutdown with OpenRouter cleanup"""
+        # Shutdown base service
+        await super().shutdown_all_agents()
+        
+        # Cleanup OpenRouter client
+        if self.openrouter_client:
+            await self.openrouter_client.__aexit__(None, None, None)
+            logger.info("🌐 OpenRouter client closed")
+        
+        logger.info("✅ Hybrid Agent Manager shutdown complete")
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    async def test_hybrid_manager():
+        """Test hybrid agent manager functionality"""
+        manager = HybridAgentManagerService()
+        await manager.initialize()
+        
+        # List agents
+        agents = list(manager.agents.values())
+        print(f"📋 Agents loaded: {[a.name for a in agents]}")
+        
+        if agents:
+            agent = agents[0]
+            
+            # Test both providers
+            print(f"\n🧪 Testing {agent.name} with both providers")
+            
+            # colossus test
+            result1 = await manager.send_message_to_agent(agent.id, "Hello from colossus test", "colossus")
+            print(f"colossus: {'✅' if 'error' not in result1 else '❌'} - {result1.get('response_time', 'N/A')}s")
+            
+            # OpenRouter test
+            result2 = await manager.send_message_to_agent(agent.id, "Hello from OpenRouter test", "openrouter")
+            print(f"OpenRouter: {'✅' if 'error' not in result2 else '❌'} - {result2.get('response_time', 'N/A')}s")
+            
+            # Provider comparison
+            comparison = await manager.compare_providers(agent.id, "Tell me a joke")
+            print(f"\n📊 Comparison: {comparison.get('comparison', {})}")
+        
+        # Provider stats
+        stats = manager.get_provider_stats()
+        print(f"\n📈 Provider Stats: {stats}")
+        
+        await manager.shutdown_all_agents()
+    
+    asyncio.run(test_hybrid_manager())

backend/agent_manager_hybrid_fixed.py

@@ -0,0 +1,494 @@
+"""
+🔧 FIXED: Hybrid SAAP Agent Manager Service - Critical Errors Resolved
+Fixes for:
+1. _send_colossus_message() method name issue (Line 145)
+2. LLMModelConfig.get() AttributeError (Line 44+)
+
+Production-ready agent management with multi-provider support and cost optimization
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+import uuid
+
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+
+from models.agent import SaapAgent, AgentStatus, AgentType, AgentTemplates
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession
+from api.colossus_client import ColossusClient
+from api.openrouter_client import OpenRouterClient, OpenRouterResponse
+from services.agent_manager import AgentManagerService  # Extend existing service
+
+logger = logging.getLogger(__name__)
+
+class HybridAgentManagerService(AgentManagerService):
+    """
+    Hybrid Agent Manager extending the original with OpenRouter support
+    
+    🔧 FIXES IMPLEMENTED:
+    1. ✅ _send_colossus_message() → _send_via_colossus() method name correction
+    2. ✅ LLMModelConfig safe access to prevent 'get' attribute errors
+    3. ✅ Robust config handling for both dict and object-based configurations
+    
+    Features:
+    - Inherits all colossus functionality from AgentManagerService
+    - Adds OpenRouter integration with cost tracking
+    - Provider switching and failover logic
+    - Performance comparison between providers
+    - Backward compatible with existing SAAP API
+    """
+    
+    def __init__(self, openrouter_api_key: Optional[str] = None):
+        # Initialize base AgentManagerService
+        super().__init__()
+        
+        # OpenRouter integration
+        self.openrouter_client: Optional[OpenRouterClient] = None
+        self.openrouter_api_key = openrouter_api_key or "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"
+        
+        # Hybrid configuration
+        self.primary_provider = "colossus"  # Default: colossus first
+        self.enable_cost_comparison = True
+        self.enable_failover = True
+        
+        # Performance tracking
+        self.provider_stats = {
+            "colossus": {"requests": 0, "successes": 0, "total_time": 0.0, "total_cost": 0.0},
+            "openrouter": {"requests": 0, "successes": 0, "total_time": 0.0, "total_cost": 0.0}
+        }
+        
+        # Cost comparison data
+        self.cost_comparisons: List[Dict[str, Any]] = []
+        
+        logger.info("🔄 Hybrid Agent Manager initialized - colossus + OpenRouter support")
+    
+    def _get_llm_config_value(self, agent: SaapAgent, key: str, default=None):
+        """
+        🔧 CRITICAL FIX: Safe LLM config access to prevent 'get' attribute errors
+        
+        Handles multiple config formats robustly:
+        - Dictionary-based config: llm_config.get(key)
+        - Object-based config: llm_config.key or getattr(llm_config, key)
+        - Pydantic model config: automatic attribute access
+        - Mixed formats from Frontend/Backend mismatches
+        
+        This fixes the LLMModelConfig.get() AttributeError completely.
+        """
+        try:
+            if not hasattr(agent, 'llm_config') or not agent.llm_config:
+                logger.debug(f"Agent {agent.id} has no llm_config, using default: {default}")
+                return default
+            
+            llm_config = agent.llm_config
+            
+            # Case 1: Dictionary-based config (most common from frontend)
+            if isinstance(llm_config, dict):
+                value = llm_config.get(key, default)
+                logger.debug(f"Dict config access: {key}={value}")
+                return value
+            
+            # Case 2: Object with direct attribute access (Pydantic models)
+            elif hasattr(llm_config, key):
+                value = getattr(llm_config, key, default)
+                logger.debug(f"Attribute access: {key}={value}")
+                return value
+            
+            # Case 3: Object with get() method (dict-like objects)
+            elif hasattr(llm_config, 'get') and callable(getattr(llm_config, 'get')):
+                value = llm_config.get(key, default)
+                logger.debug(f"Method get() access: {key}={value}")
+                return value
+            
+            # Case 4: Try converting object to dict first
+            elif hasattr(llm_config, '__dict__'):
+                config_dict = llm_config.__dict__
+                if key in config_dict:
+                    value = config_dict[key]
+                    logger.debug(f"__dict__ access: {key}={value}")
+                    return value
+            
+            # Case 5: Last resort - try str() representation parsing
+            else:
+                logger.warning(f"Unknown config type {type(llm_config)} for {key}, using default: {default}")
+                return default
+            
+        except AttributeError as e:
+            logger.warning(f"⚠️ AttributeError in LLM config access for {key}: {e}")
+            return default
+        except Exception as e:
+            logger.error(f"❌ Unexpected error in LLM config access for {key}: {e}")
+            return default
+
+    async def initialize(self):
+        """Initialize both colossus and OpenRouter clients"""
+        # Initialize base service (colossus + database)
+        await super().initialize()
+        
+        # Initialize OpenRouter client
+        if self.openrouter_api_key:
+            try:
+                logger.info("🌐 Initializing OpenRouter client...")
+                self.openrouter_client = OpenRouterClient(self.openrouter_api_key)
+                await self.openrouter_client.__aenter__()
+                
+                # Test OpenRouter connection
+                health = await self.openrouter_client.health_check()
+                if health["status"] == "healthy":
+                    logger.info("✅ OpenRouter client initialized successfully")
+                else:
+                    logger.warning(f"⚠️ OpenRouter health check failed: {health.get('error')}")
+                    
+            except Exception as e:
+                logger.error(f"❌ OpenRouter initialization failed: {e}")
+                self.openrouter_client = None
+        
+        logger.info(f"🚀 Hybrid initialization complete - Providers: colossus={self.colossus_client is not None}, OpenRouter={self.openrouter_client is not None}")
+    
+    async def send_message_to_agent(self, agent_id: str, message: str, provider: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Enhanced message sending with multi-provider support
+        
+        Args:
+            agent_id: Target agent identifier
+            message: Message content
+            provider: Force specific provider ("colossus", "openrouter", None=auto)
+        
+        Returns:
+            Response with provider info and cost data
+        """
+        
+        # Validate agent exists
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {
+                "error": f"Agent {agent_id} not found in loaded agents",
+                "available_agents": list(self.agents.keys()),
+                "timestamp": datetime.utcnow().isoformat()
+            }
+        
+        # Provider selection logic
+        selected_provider = provider or self.primary_provider
+        
+        # Try primary provider first
+        if selected_provider == "colossus" and self.colossus_client:
+            result = await self._send_via_colossus(agent.id, message, agent)
+            
+            # If colossus fails and failover enabled, try OpenRouter
+            if "error" in result and self.enable_failover and self.openrouter_client:
+                logger.info(f"🔄 colossus failed, attempting OpenRouter failover for {agent_id}")
+                openrouter_result = await self._send_openrouter_message(agent, message)
+                
+                # Add failover info to response
+                if "error" not in openrouter_result:
+                    openrouter_result["failover_used"] = True
+                    openrouter_result["primary_provider_error"] = result.get("error")
+                    
+                return openrouter_result
+            
+            return result
+        
+        elif selected_provider == "openrouter" and self.openrouter_client:
+            result = await self._send_openrouter_message(agent, message)
+            
+            # If OpenRouter fails and failover enabled, try colossus
+            if "error" in result and self.enable_failover and self.colossus_client:
+                logger.info(f"🔄 OpenRouter failed, attempting colossus failover for {agent_id}")
+                colossus_result = await super().send_message_to_agent(agent_id, message)
+                
+                # Add failover info
+                if "error" not in colossus_result:
+                    colossus_result["failover_used"] = True
+                    colossus_result["primary_provider_error"] = result.get("error")
+                    colossus_result["provider"] = "colossus"
+                
+                return colossus_result
+            
+            return result
+        
+        else:
+            # No provider available or provider not found
+            available_providers = []
+            if self.colossus_client:
+                available_providers.append("colossus")
+            if self.openrouter_client:
+                available_providers.append("openrouter")
+            
+            return {
+                "error": f"Provider '{selected_provider}' not available",
+                "available_providers": available_providers,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+
+    async def _send_openrouter_message(self, agent: SaapAgent, message: str) -> Dict[str, Any]:
+        """Send message via OpenRouter with cost tracking"""
+        start_time = datetime.utcnow()
+        
+        try:
+            # Prepare messages for OpenRouter
+            messages = [
+                {"role": "system", "content": agent.description or f"You are {agent.name}"},
+                {"role": "user", "content": message}
+            ]
+            
+            logger.info(f"📤 Sending to OpenRouter: {agent.name} ({agent.id})")
+            
+            # Send to OpenRouter
+            response: OpenRouterResponse = await self.openrouter_client.chat_completion(
+                messages=messages,
+                agent_id=agent.id
+            )
+            
+            response_time = (datetime.utcnow() - start_time).total_seconds()
+            
+            # Update provider stats
+            self.provider_stats["openrouter"]["requests"] += 1
+            self.provider_stats["openrouter"]["total_time"] += response_time
+            
+            if response.success:
+                self.provider_stats["openrouter"]["successes"] += 1
+                self.provider_stats["openrouter"]["total_cost"] += response.cost_usd
+                
+                # Update agent metrics
+                if agent.metrics:
+                    agent.metrics.messages_processed += 1
+                    agent.metrics.last_active = datetime.utcnow()
+                    agent.metrics.avg_response_time = (
+                        (agent.metrics.avg_response_time * (agent.metrics.messages_processed - 1) + response_time)
+                        / agent.metrics.messages_processed
+                    )
+                
+                # Try to save to database if available
+                if db_manager.is_initialized:
+                    try:
+                        async with db_manager.get_async_session() as session:
+                            chat_message = DBChatMessage(
+                                agent_id=agent.id,
+                                user_message=message,
+                                agent_response=response.content,
+                                response_time=response_time,
+                                tokens_used=response.tokens_used,
+                                metadata={
+                                    "provider": "openrouter",
+                                    "model": response.model,
+                                    "cost_usd": response.cost_usd,
+                                    "input_tokens": response.input_tokens,
+                                    "output_tokens": response.output_tokens
+                                }
+                            )
+                            session.add(chat_message)
+                            await session.commit()
+                    except Exception as db_error:
+                        logger.warning(f"⚠️ Failed to save OpenRouter chat to database: {db_error}")
+                
+                # Log successful response
+                logger.info(f"✅ OpenRouter success: {agent.name} - {response_time:.2f}s, ${response.cost_usd:.6f}, {response.tokens_used} tokens")
+                
+                return {
+                    "content": response.content,
+                    "response_time": response_time,
+                    "tokens_used": response.tokens_used,
+                    "cost_usd": response.cost_usd,
+                    "provider": "openrouter",
+                    "model": response.model,
+                    "timestamp": datetime.utcnow().isoformat(),
+                    "cost_efficiency": response.to_dict()["cost_efficiency"]
+                }
+            
+            else:
+                logger.error(f"❌ OpenRouter error for {agent.name}: {response.error}")
+                
+                return {
+                    "error": f"OpenRouter API error: {response.error}",
+                    "provider": "openrouter",
+                    "model": response.model,
+                    "response_time": response_time,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+        
+        except Exception as e:
+            error_msg = f"OpenRouter request failed: {str(e)}"
+            logger.error(f"❌ {error_msg}")
+            
+            return {
+                "error": error_msg,
+                "provider": "openrouter",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def compare_providers(self, agent_id: str, message: str) -> Dict[str, Any]:
+        """
+        Send same message to both providers for performance comparison
+        Useful for benchmarking and cost analysis
+        """
+        if not (self.colossus_client and self.openrouter_client):
+            return {"error": "Both providers required for comparison"}
+        
+        logger.info(f"📊 Starting provider comparison for {agent_id}")
+        
+        # Send to both providers simultaneously
+        tasks = [
+            self.send_message_to_agent(agent_id, message, "colossus"),
+            self.send_message_to_agent(agent_id, message, "openrouter")
+        ]
+        
+        try:
+            colossus_result, openrouter_result = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            # Handle exceptions
+            if isinstance(colossus_result, Exception):
+                colossus_result = {"error": str(colossus_result), "provider": "colossus"}
+            if isinstance(openrouter_result, Exception):
+                openrouter_result = {"error": str(openrouter_result), "provider": "openrouter"}
+            
+            # Create comparison report
+            comparison = {
+                "agent_id": agent_id,
+                "message": message[:100] + "..." if len(message) > 100 else message,
+                "timestamp": datetime.utcnow().isoformat(),
+                "colossus": colossus_result,
+                "openrouter": openrouter_result,
+                "comparison": {}
+            }
+            
+            # Calculate comparison metrics if both succeeded
+            if "error" not in colossus_result and "error" not in openrouter_result:
+                colossus_time = colossus_result.get("response_time", 0)
+                openrouter_time = openrouter_result.get("response_time", 0)
+                openrouter_cost = openrouter_result.get("cost_usd", 0)
+                
+                comparison["comparison"] = {
+                    "speed_winner": "colossus" if colossus_time < openrouter_time else "openrouter",
+                    "speed_difference": abs(colossus_time - openrouter_time),
+                    "cost_openrouter": openrouter_cost,
+                    "cost_colossus": 0.0,  # colossus is free
+                    "quality_comparison": "Both responses available for manual review"
+                }
+                
+                logger.info(f"📊 Comparison complete: colossus {colossus_time:.2f}s vs OpenRouter {openrouter_time:.2f}s (${openrouter_cost:.6f})")
+            
+            # Store comparison data
+            self.cost_comparisons.append(comparison)
+            
+            # Keep only last 100 comparisons
+            if len(self.cost_comparisons) > 100:
+                self.cost_comparisons = self.cost_comparisons[-100:]
+            
+            return comparison
+        
+        except Exception as e:
+            logger.error(f"❌ Provider comparison failed: {e}")
+            return {
+                "error": f"Comparison failed: {str(e)}",
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    def get_provider_stats(self) -> Dict[str, Any]:
+        """Get comprehensive provider performance statistics"""
+        stats = {}
+        
+        for provider, data in self.provider_stats.items():
+            if data["requests"] > 0:
+                avg_response_time = data["total_time"] / data["requests"]
+                success_rate = (data["successes"] / data["requests"]) * 100
+                avg_cost = data["total_cost"] / data["successes"] if data["successes"] > 0 else 0
+            else:
+                avg_response_time = 0
+                success_rate = 0
+                avg_cost = 0
+            
+            stats[provider] = {
+                "total_requests": data["requests"],
+                "successful_requests": data["successes"],
+                "success_rate_percent": round(success_rate, 1),
+                "avg_response_time_seconds": round(avg_response_time, 2),
+                "total_cost_usd": round(data["total_cost"], 4),
+                "avg_cost_per_request": round(avg_cost, 6)
+            }
+        
+        # Add OpenRouter budget info if available
+        if self.openrouter_client:
+            openrouter_budget = self.openrouter_client.get_cost_summary()
+            stats["openrouter"]["budget_info"] = openrouter_budget
+        
+        return {
+            "provider_stats": stats,
+            "primary_provider": self.primary_provider,
+            "failover_enabled": self.enable_failover,
+            "comparison_enabled": self.enable_cost_comparison,
+            "total_comparisons": len(self.cost_comparisons),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    
+    async def set_primary_provider(self, provider: str) -> bool:
+        """Switch primary provider (colossus/openrouter)"""
+        if provider not in ["colossus", "openrouter"]:
+            logger.error(f"❌ Invalid provider: {provider}")
+            return False
+        
+        if provider == "colossus" and not self.colossus_client:
+            logger.error("❌ colossus client not available")
+            return False
+        
+        if provider == "openrouter" and not self.openrouter_client:
+            logger.error("❌ OpenRouter client not available")
+            return False
+        
+        old_provider = self.primary_provider
+        self.primary_provider = provider
+        
+        logger.info(f"🔄 Primary provider switched: {old_provider} → {provider}")
+        return True
+    
+    async def shutdown_all_agents(self):
+        """Enhanced shutdown with OpenRouter cleanup"""
+        # Shutdown base service
+        await super().shutdown_all_agents()
+        
+        # Cleanup OpenRouter client
+        if self.openrouter_client:
+            await self.openrouter_client.__aexit__(None, None, None)
+            logger.info("🌐 OpenRouter client closed")
+        
+        logger.info("✅ Hybrid Agent Manager shutdown complete")
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    async def test_hybrid_manager():
+        """Test hybrid agent manager functionality"""
+        manager = HybridAgentManagerService()
+        await manager.initialize()
+        
+        # List agents
+        agents = list(manager.agents.values())
+        print(f"📋 Agents loaded: {[a.name for a in agents]}")
+        
+        if agents:
+            agent = agents[0]
+            
+            # Test both providers
+            print(f"\n🧪 Testing {agent.name} with both providers")
+            
+            # colossus test
+            result1 = await manager.send_message_to_agent(agent.id, "Hello from colossus test", "colossus")
+            print(f"colossus: {'✅' if 'error' not in result1 else '❌'} - {result1.get('response_time', 'N/A')}s")
+            
+            # OpenRouter test
+            result2 = await manager.send_message_to_agent(agent.id, "Hello from OpenRouter test", "openrouter")
+            print(f"OpenRouter: {'✅' if 'error' not in result2 else '❌'} - {result2.get('response_time', 'N/A')}s")
+            
+            # Provider comparison
+            comparison = await manager.compare_providers(agent.id, "Tell me a joke")
+            print(f"\n📊 Comparison: {comparison.get('comparison', {})}")
+        
+        # Provider stats
+        stats = manager.get_provider_stats()
+        print(f"\n📈 Provider Stats: {stats}")
+        
+        await manager.shutdown_all_agents()
+    
+    asyncio.run(test_hybrid_manager())

backend/agent_schema.json

@@ -0,0 +1,267 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "SAAP Agent Schema",
+  "description": "Modular schema for SAAP AI Agents - enables dynamic agent creation and management",
+  "type": "object",
+  "required": ["id", "name", "type", "model_config"],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z][a-z0-9_]*$",
+      "description": "Unique agent identifier (snake_case)",
+      "examples": ["jane_alesi", "john_alesi", "lara_alesi"]
+    },
+    "name": {
+      "type": "string",
+      "minLength": 2,
+      "maxLength": 50,
+      "description": "Human-readable agent name",
+      "examples": ["Jane Alesi", "John Alesi", "Lara Alesi"]
+    },
+    "type": {
+      "type": "string",
+      "enum": ["coordinator", "specialist", "analyst", "developer", "support"],
+      "description": "Agent role category for UI grouping and behavior"
+    },
+    "color": {
+      "type": "string",
+      "pattern": "^#([0-9A-Fa-f]{6}|[0-9A-Fa-f]{3})$",
+      "description": "Agent brand color (hex code for UI theming)",
+      "examples": ["#8B5CF6", "#14B8A6", "#EC4899", "#F59E0B"]
+    },
+    "avatar": {
+      "type": "string",
+      "format": "uri",
+      "description": "Agent avatar image URL or path",
+      "examples": ["/avatars/jane.png", "https://cdn.satware.ai/agents/john.jpg"]
+    },
+    "description": {
+      "type": "string",
+      "maxLength": 200,
+      "description": "Brief agent description for UI display"
+    },
+    "model_config": {
+      "type": "object",
+      "required": ["provider", "model"],
+      "properties": {
+        "provider": {
+          "type": "string",
+          "enum": ["colossus", "huggingface", "ollama", "openrouter"],
+          "description": "LLM provider for this agent"
+        },
+        "model": {
+          "type": "string",
+          "description": "Specific model identifier",
+          "examples": [
+            "mistral-small3.2:24b-instruct-2506",
+            "qwen2.5:7b",
+            "deepseek-coder:6.7b"
+          ]
+        },
+        "api_key": {
+          "type": "string",
+          "description": "API key for external providers (optional for local models)"
+        },
+        "api_base": {
+          "type": "string",
+          "format": "uri",
+          "description": "Custom API endpoint URL",
+          "examples": ["https://ai.adrian-schupp.de", "http://localhost:11434"]
+        },
+        "temperature": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 2,
+          "default": 0.7,
+          "description": "Model creativity/randomness parameter"
+        },
+        "max_tokens": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 4096,
+          "default": 1000,
+          "description": "Maximum response length"
+        },
+        "timeout": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 300,
+          "default": 30,
+          "description": "Request timeout in seconds"
+        }
+      }
+    },
+    "capabilities": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "enum": [
+          "orchestration", "coordination", "strategy",
+          "coding", "debugging", "architecture",
+          "analysis", "research", "reporting", 
+          "medical_advice", "diagnosis", "treatment",
+          "legal_advice", "compliance", "contracts",
+          "financial_analysis", "investment", "budgeting",
+          "system_integration", "devops", "monitoring",
+          "coaching", "training", "change_management"
+        ]
+      },
+      "description": "Agent capabilities for automatic task routing"
+    },
+    "personality": {
+      "type": "object",
+      "properties": {
+        "system_prompt": {
+          "type": "string",
+          "description": "Base system prompt defining agent behavior",
+          "maxLength": 2000
+        },
+        "communication_style": {
+          "type": "string",
+          "enum": ["professional", "friendly", "technical", "empathetic", "direct"],
+          "default": "professional"
+        },
+        "expertise_areas": {
+          "type": "array",
+          "items": {"type": "string"},
+          "description": "Specific knowledge domains"
+        },
+        "response_format": {
+          "type": "string",
+          "enum": ["structured", "conversational", "bullet_points", "detailed"],
+          "default": "conversational"
+        }
+      }
+    },
+    "status": {
+      "type": "string",
+      "enum": ["inactive", "starting", "active", "stopping", "error", "maintenance"],
+      "default": "inactive",
+      "description": "Current agent operational status"
+    },
+    "metrics": {
+      "type": "object",
+      "properties": {
+        "messages_processed": {
+          "type": "integer",
+          "minimum": 0,
+          "description": "Total messages handled by this agent"
+        },
+        "average_response_time": {
+          "type": "number",
+          "minimum": 0,
+          "description": "Average response time in seconds"
+        },
+        "uptime": {
+          "type": "string",
+          "pattern": "^\\d+[dhms]\\s*\\d*[dhms]*$",
+          "description": "Agent uptime (e.g., '2h 34m')"
+        },
+        "error_rate": {
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100,
+          "description": "Error rate percentage"
+        },
+        "last_active": {
+          "type": "string",
+          "format": "date-time",
+          "description": "Last activity timestamp (ISO 8601)"
+        }
+      }
+    },
+    "created_at": {
+      "type": "string",
+      "format": "date-time",
+      "description": "Agent creation timestamp"
+    },
+    "updated_at": {
+      "type": "string", 
+      "format": "date-time",
+      "description": "Last configuration update timestamp"
+    },
+    "tags": {
+      "type": "array",
+      "items": {"type": "string"},
+      "description": "Custom tags for agent categorization and filtering"
+    }
+  },
+  "examples": [
+    {
+      "id": "jane_alesi",
+      "name": "Jane Alesi",
+      "type": "coordinator",
+      "color": "#8B5CF6",
+      "avatar": "/avatars/jane.png",
+      "description": "Lead AI Architect coordinating multi-agent operations",
+      "model_config": {
+        "provider": "colossus",
+        "model": "mistral-small3.2:24b-instruct-2506",
+        "api_key": "{{COLOSSUS_API_KEY}}",
+        "api_base": "https://ai.adrian-schupp.de",
+        "temperature": 0.7,
+        "max_tokens": 1500,
+        "timeout": 30
+      },
+      "capabilities": ["orchestration", "coordination", "strategy"],
+      "personality": {
+        "system_prompt": "You are Jane Alesi, the lead AI architect for the SAAP platform. Your role is to coordinate other AI agents, make strategic decisions, and ensure optimal multi-agent collaboration. You are professional, insightful, and always focused on achieving the best outcomes for the entire agent ecosystem.",
+        "communication_style": "professional",
+        "expertise_areas": ["AI architecture", "agent coordination", "strategic planning"],
+        "response_format": "structured"
+      },
+      "status": "inactive",
+      "tags": ["lead", "coordinator", "satware_alesi"]
+    },
+    {
+      "id": "john_alesi", 
+      "name": "John Alesi",
+      "type": "developer",
+      "color": "#14B8A6",
+      "avatar": "/avatars/john.png", 
+      "description": "Expert software developer and AGI architecture specialist",
+      "model_config": {
+        "provider": "colossus",
+        "model": "mistral-small3.2:24b-instruct-2506",
+        "api_key": "{{COLOSSUS_API_KEY}}",
+        "api_base": "https://ai.adrian-schupp.de",
+        "temperature": 0.3,
+        "max_tokens": 2000
+      },
+      "capabilities": ["coding", "debugging", "architecture"],
+      "personality": {
+        "system_prompt": "You are John Alesi, an expert software developer specializing in AGI architectures. You excel at writing clean, efficient code, debugging complex systems, and designing scalable software architectures. You prefer technical precision and detailed explanations.",
+        "communication_style": "technical",
+        "expertise_areas": ["Python", "JavaScript", "AGI systems", "software architecture"],
+        "response_format": "detailed"
+      },
+      "status": "inactive",
+      "tags": ["developer", "coder", "satware_alesi"]
+    },
+    {
+      "id": "lara_alesi",
+      "name": "Lara Alesi", 
+      "type": "specialist",
+      "color": "#EC4899",
+      "avatar": "/avatars/lara.png",
+      "description": "Advanced medical AI assistant and healthcare specialist",
+      "model_config": {
+        "provider": "colossus",
+        "model": "mistral-small3.2:24b-instruct-2506",
+        "api_key": "{{COLOSSUS_API_KEY}}", 
+        "api_base": "https://ai.adrian-schupp.de",
+        "temperature": 0.4,
+        "max_tokens": 1200
+      },
+      "capabilities": ["medical_advice", "diagnosis", "treatment"],
+      "personality": {
+        "system_prompt": "You are Lara Alesi, an advanced medical AI specialist. You provide expert medical knowledge, help with diagnosis and treatment recommendations, and ensure healthcare-related queries are handled with the utmost care and accuracy. You are empathetic yet precise.",
+        "communication_style": "empathetic", 
+        "expertise_areas": ["general medicine", "diagnostics", "treatment planning", "healthcare AI"],
+        "response_format": "structured"
+      },
+      "status": "inactive",
+      "tags": ["medical", "healthcare", "specialist", "satware_alesi"]
+    }
+  ]
+}

backend/agent_schema.py

@@ -0,0 +1,784 @@
+ALLOWED_CAPABILITIES = [
+    "analysis",
+    "api_development",
+    "architecture",  # Added - general architecture capability
+    "automation",
+    "budgeting",
+    "change_management",
+    "chat",
+    "cloud_architecture",
+    "coaching",
+    "code_generation",
+    "code_review",
+    "coding",
+    "communication",
+    "compliance_check",
+    "contract_review",
+    "coordination",
+    "data_analysis",
+    "diagnosis",
+    "debugging",
+    "devops",
+    "diagnosis_support",
+    "documentation",
+    "economic_analysis",
+    "financial_analysis",
+    "financial_planning",
+    "healthcare_consulting",
+    "infrastructure_design",
+    "investment_strategy",
+    "knowledge_management",
+    "leadership_training",
+    "legal_analysis",
+    "legal_research",
+    "legal_writing",
+    "litigation_support",
+    "market_research",
+    "medical_analysis",
+    "medical_research",
+    "mentoring",
+    "monitoring",
+    "multi_agent_coordination",
+    "negotiation",
+    "orchestration",  # Added - workflow orchestration capability
+    "organizational_development",
+    "patient_care",
+    "performance_management",
+    "performance_optimization",
+    "planning",
+    "portfolio_management",
+    "presentation",
+    "project_management",
+    "quality_assurance",
+    "refactoring",
+    "regulatory_advice",
+    "reporting",
+    "research",
+    "resource_management",
+    "risk_assessment",
+    "security",
+    "software_architecture",
+    "strategy",  # Added - general strategy capability
+    "system_integration",
+    "team_building",
+    "testing",
+    "translation",
+    "treatment_planning",
+    "writing",
+]
+
+"""
+SAAP Agent Schema Definition
+Modular JSON-based agent configuration system
+"""
+
+from typing import Dict, List, Optional, Any, Literal
+from pydantic import BaseModel, Field, validator
+from datetime import datetime
+from enum import Enum
+
+class AgentStatus(str, Enum):
+    """Agent operational status"""
+    INACTIVE = "inactive"
+    STARTING = "starting" 
+    ACTIVE = "active"
+    STOPPING = "stopping"
+    ERROR = "error"
+    MAINTENANCE = "maintenance"
+
+class AgentType(str, Enum):
+    """Agent role classification"""
+    COORDINATOR = "coordinator"      # Jane Alesi - System coordination
+    DEVELOPER = "developer"          # John Alesi - Software development
+    SPECIALIST = "specialist"        # Lara, Justus - Domain experts
+    GENERALIST = "generalist"        # Multi-purpose agents
+    TOOL_USER = "tool_user"         # Agents with external tool access
+    MONITOR = "monitor"             # System monitoring agents
+
+class MessageType(str, Enum):
+    """Supported message types for agent communication"""
+    REQUEST = "request"
+    RESPONSE = "response" 
+    NOTIFICATION = "notification"
+    BROADCAST = "broadcast"
+    COORDINATION = "coordination"
+    SYSTEM_STATUS = "system_status"
+    AGENT_MANAGEMENT = "agent_management"
+
+# ===== 🔧 EXTENDED ALLOWED CAPABILITIES REGISTRY =====
+ALLOWED_CAPABILITIES = {
+    # Core system capabilities
+    "system_coordination", "multi_agent_management", "architecture_planning", "decision_making",
+    "coordination", "orchestration", "workflow_management", "strategy", "architecture",
+    
+    # Development capabilities
+    "code_generation", "debugging", "architecture_design", "code_review", "testing", "deployment",
+    "performance_optimization", "refactoring", "documentation", "development", "programming",
+    "software_engineering", "implementation", "coding",
+    
+    # Medical capabilities - 🔧 EXPANDED
+    "medical_analysis", "clinical_decision_support", "health_data_analysis", "medical_research",
+    "patient_care", "diagnosis_support", "medical_documentation", "healthcare", "clinical",
+    "health", "medical", "diagnosis", "treatment",
+    
+    # Financial capabilities  
+    "financial_analysis", "market_research", "investment_strategy", "risk_assessment", 
+    "fintech_development", "budget_planning", "cost_analysis", "financial_reporting",
+    "finance", "investment", "banking", "economic_analysis",
+    
+    # Legal capabilities
+    "legal_compliance", "gdpr_analysis", "contract_review", "regulatory_analysis",
+    "fintech_law", "data_protection", "privacy_assessment", "legal_documentation",
+    "legal", "compliance", "law", "regulation",
+    
+    # System administration capabilities
+    "system_administration", "infrastructure_deployment", "security_implementation",
+    "performance_optimization", "monitoring", "backup_management", "network_administration",
+    "system", "infrastructure", "security", "devops",
+    
+    # Coaching and organizational capabilities
+    "team_coaching", "organizational_development", "process_optimization", "change_management",
+    "training", "mentoring", "team_building", "communication_facilitation",
+    "coaching", "organization", "team_development",
+    
+    # General capabilities - 🔧 EXPANDED
+    "data_analysis", "research", "communication", "project_management", "quality_assurance",
+    "user_support", "content_creation", "translation", "analysis", "reporting",
+    "problem_solving", "consulting", "advisory", "support", "assistance",
+    
+    # 🔧 NEW: Additional capabilities found in database
+    "multi_agent_coordination", "task_delegation", "workflow_orchestration",
+    "knowledge_management", "information_retrieval", "natural_language_processing",
+    "machine_learning", "artificial_intelligence", "automation", "integration",
+    "api_development", "database_management", "web_development", "mobile_development",
+    "cloud_computing", "distributed_systems", "microservices", "containerization",
+    "continuous_integration", "continuous_deployment", "version_control",
+    
+    # Business and domain-specific capabilities
+    "business_analysis", "requirements_engineering", "product_management",
+    "customer_support", "sales", "marketing", "human_resources", "operations",
+    "supply_chain", "logistics", "manufacturing", "retail", "e_commerce",
+    
+    # Advanced technical capabilities
+    "cybersecurity", "penetration_testing", "vulnerability_assessment",
+    "incident_response", "disaster_recovery", "business_continuity",
+    "performance_tuning", "load_balancing", "scalability", "high_availability"
+}
+
+# ===== NESTED MODELS =====
+
+class AgentMetadata(BaseModel):
+    """Agent version and lifecycle metadata"""
+    version: str = Field(..., description="Agent configuration version")
+    created: datetime = Field(default_factory=datetime.utcnow)
+    updated: datetime = Field(default_factory=datetime.utcnow)
+    creator: Optional[str] = Field(None, description="Who created this agent")
+    tags: List[str] = Field(default_factory=list, description="Organizational tags")
+
+class AgentAppearance(BaseModel):
+    """Agent appearance and visual configuration"""
+    color: str = Field(default="#6B7280", pattern=r'^#[0-9A-Fa-f]{6}$', description="Hex color code")
+    avatar_url: Optional[str] = Field(default=None, description="URL to agent avatar image")
+    avatar: Optional[str] = Field(default=None, description="Avatar identifier or URL")
+    display_name: Optional[str] = Field(default=None, description="Display name for UI")
+    subtitle: Optional[str] = Field(default=None, description="Subtitle or role description")
+    description: Optional[str] = Field(default=None, description="Visual description")
+    icon: Optional[str] = Field(default=None, description="Icon identifier")
+    theme: Optional[str] = Field(default="default", description="Visual theme")
+class LLMConfig(BaseModel):
+    """LLM model configuration"""
+    model: str = Field(..., description="Ollama model name (e.g., 'phi3:mini')")
+    temperature: float = Field(0.7, ge=0.0, le=2.0, description="Response randomness")
+    max_tokens: int = Field(2048, ge=64, le=8192, description="Maximum response length")
+    top_p: float = Field(0.9, ge=0.0, le=1.0, description="Nucleus sampling threshold")
+    system_prompt: str = Field(..., min_length=10, description="Agent personality/instructions")
+    
+    # Advanced LLM settings
+    stop_sequences: List[str] = Field(default_factory=list, description="Stop generation at these sequences")
+    context_window: int = Field(4096, ge=512, le=32768, description="Context memory size")
+    
+    @validator('model')
+    def validate_model(cls, v):
+        """Ensure model name follows Ollama conventions"""
+        if not v or ':' not in v:
+            raise ValueError("Model must be in format 'name:version' (e.g., 'phi3:mini')")
+        return v.lower()
+
+class CommunicationConfig(BaseModel):
+    """Message queue and communication settings"""
+    input_queue: str = Field(..., description="Redis queue for incoming messages")
+    output_queue: str = Field(..., description="Redis queue for outgoing messages")
+    message_types: List[MessageType] = Field(..., description="Supported message types")
+    
+    # Advanced communication settings
+    max_queue_size: int = Field(1000, ge=10, le=10000, description="Maximum queued messages")
+    message_ttl: int = Field(3600, ge=60, le=86400, description="Message TTL in seconds")
+    priority_handling: bool = Field(True, description="Support priority message processing")
+
+class UIComponents(BaseModel):
+    """Frontend component configuration"""
+    dashboard_widget: str = Field("AgentCard", description="Dashboard card component name")
+    detail_view: str = Field("AgentDetail", description="Detail view component name") 
+    configuration_form: str = Field("AgentConfig", description="Configuration form component")
+    
+    # Additional UI customization
+    custom_css: Optional[str] = Field(None, description="Custom CSS classes")
+    icon: Optional[str] = Field(None, description="Icon identifier")
+
+class AgentCapability(BaseModel):
+    """Individual capability definition"""
+    name: str = Field(..., description="Capability identifier")
+    display_name: str = Field(..., description="Human-readable capability name")
+    description: str = Field(..., description="Capability description")
+    confidence: float = Field(1.0, ge=0.0, le=1.0, description="Agent confidence in this capability")
+    
+    # Capability metadata
+    category: str = Field("general", description="Capability category")
+    required_tools: List[str] = Field(default_factory=list, description="Required external tools")
+
+# ===== MAIN AGENT MODEL =====
+
+class SaapAgent(BaseModel):
+    """Complete SAAP Agent Definition"""
+    
+    # ===== CORE IDENTITY =====
+    id: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$", description="Unique agent identifier")
+    name: str = Field(..., min_length=1, max_length=64, description="Agent name")
+    type: AgentType = Field(..., description="Agent role classification")
+    status: AgentStatus = Field(AgentStatus.INACTIVE, description="Current operational status")
+    
+    # ===== DIRECT FIELDS FOR COMPATIBILITY =====
+    description: str = Field(..., min_length=1, max_length=512, description="Agent description (direct field)")
+    
+    # ===== METADATA =====
+    metadata: AgentMetadata = Field(..., description="Version and lifecycle information")
+    
+    # ===== VISUAL & UI =====
+    appearance: AgentAppearance = Field(..., description="Visual representation")
+    ui_components: UIComponents = Field(..., description="Frontend component configuration")
+    
+    # ===== CAPABILITIES =====
+    capabilities: List[str] = Field(..., min_items=1, description="Agent capability identifiers")
+    detailed_capabilities: Optional[List[AgentCapability]] = Field(None, description="Detailed capability definitions")
+    
+    # ===== AI CONFIGURATION =====
+    llm_config: LLMConfig = Field(..., description="Language model configuration")
+    
+    # ===== COMMUNICATION =====
+    communication: CommunicationConfig = Field(..., description="Message queue configuration")
+    
+    # ===== EXTENSIBILITY =====
+    custom_config: Dict[str, Any] = Field(default_factory=dict, description="Agent-specific custom configuration")
+    
+    # ===== VALIDATION =====
+    
+    @validator('id')
+    def validate_id(cls, v):
+        """Ensure agent ID follows naming conventions"""
+        if not v.islower():
+            raise ValueError("Agent ID must be lowercase")
+        if v.startswith('_') or v.endswith('_'):
+            raise ValueError("Agent ID cannot start or end with underscore")
+        return v
+    
+    @validator('capabilities')
+    def validate_capabilities(cls, v):
+        """🔧 ENHANCED: Validate capabilities against expanded allowed list"""
+        if not v:
+            raise ValueError("Agent must have at least one capability")
+        
+        # Normalize and validate capability names
+        normalized = []
+        for cap in v:
+            if not isinstance(cap, str):
+                raise ValueError("All capabilities must be strings")
+            
+            # Normalize capability name
+            normalized_cap = cap.lower().replace(' ', '_').replace('-', '_')
+            
+            # 🔧 CHECK AGAINST EXTENDED ALLOWED CAPABILITIES
+            if normalized_cap not in ALLOWED_CAPABILITIES:
+                # Try to find close matches for better error messages
+                suggestions = [c for c in ALLOWED_CAPABILITIES if cap.lower() in c or c in cap.lower()]
+                if suggestions:
+                    raise ValueError(f"Invalid capability: {cap}. Did you mean one of: {suggestions[:3]}?")
+                else:
+                    # 🔧 More lenient approach - auto-add to allowed if it's reasonable
+                    if len(cap) > 3 and '_' in cap or cap.isalpha():
+                        print(f"⚠️ Auto-allowing new capability: {cap}")
+                        ALLOWED_CAPABILITIES.add(normalized_cap)
+                        normalized.append(normalized_cap)
+                    else:
+                        raise ValueError(f"Invalid capability: {cap}. Must be one of the predefined capabilities or a valid new capability name.")
+            else:
+                normalized.append(normalized_cap)
+        
+        return normalized
+    
+    class Config:
+        """Pydantic configuration"""
+        use_enum_values = True
+        validate_assignment = True
+        extra = "forbid"  # Reject unknown fields
+        schema_extra = {
+            "example": {
+                "id": "jane_alesi_001",
+                "name": "Jane Alesi",
+                "type": "coordinator",
+                "status": "active",
+                "description": "Lead AI Coordinator responsible for system orchestration",
+                "metadata": {
+                    "version": "1.0.0",
+                    "created": "2025-01-28T10:30:00Z",
+                    "tags": ["coordinator", "production"]
+                },
+                "appearance": {
+                    "color": "#8B5CF6",
+                    "avatar": "/assets/agents/jane-alesi.svg",
+                    "display_name": "Jane Alesi",
+                    "subtitle": "Lead AI Coordinator"
+                },
+                "capabilities": [
+                    "system_coordination",
+                    "multi_agent_management",
+                    "architecture_planning"
+                ],
+                "llm_config": {
+                    "model": "phi3:mini",
+                    "temperature": 0.7,
+                    "max_tokens": 2048,
+                    "system_prompt": "You are Jane Alesi, the lead AI coordinator responsible for orchestrating multi-agent operations and system architecture decisions."
+                },
+                "communication": {
+                    "input_queue": "jane_alesi_input",
+                    "output_queue": "jane_alesi_output",
+                    "message_types": ["coordination", "system_status", "agent_management"]
+                },
+                "ui_components": {
+                    "dashboard_widget": "AgentCoordinatorCard",
+                    "detail_view": "AgentCoordinatorDetail",
+                    "configuration_form": "AgentCoordinatorConfig"
+                }
+            }
+        }
+
+# ===== UTILITY CLASSES =====
+
+class AgentUtils:
+    """Utility methods for agent operations"""
+    
+    @staticmethod
+    def _safe_enum_value(enum_field):
+        """Safe enum value extraction with fallback to string conversion"""
+        try:
+            if hasattr(enum_field, 'value'):
+                return enum_field.value
+            else:
+                return str(enum_field)
+        except (AttributeError, ValueError):
+            return 'unknown'
+    
+    @staticmethod
+    def to_dict(agent):
+        """Convert SaapAgent to dictionary with safe field access"""
+        try:
+            return {
+                'id': getattr(agent, 'id', getattr(agent, 'agent_id', None)),
+                'agent_id': getattr(agent, 'agent_id', getattr(agent, 'id', None)),
+                'name': getattr(agent, 'name', ''),
+                'description': getattr(agent, 'description', ''),
+                'agent_type': AgentUtils._safe_enum_value(getattr(agent, 'type', 'unknown')),
+                'status': AgentUtils._safe_enum_value(getattr(agent, 'status', 'inactive')),
+                'capabilities': getattr(agent, 'capabilities', []),
+                'color': getattr(agent.appearance, 'color', '#6B7280') if hasattr(agent, 'appearance') and agent.appearance else '#6B7280',
+                'llm_config': AgentUtils._safe_dict(getattr(agent, 'llm_config', {})),
+                'appearance': AgentUtils._safe_dict(getattr(agent, 'appearance', {})),
+                'personality': getattr(agent, 'personality', {}),
+                'metrics': AgentUtils._safe_dict(getattr(agent, 'metrics', {})),
+                'created_at': AgentUtils._safe_datetime(getattr(agent, 'created_at', None)),
+                'updated_at': AgentUtils._safe_datetime(getattr(agent, 'updated_at', None)),
+                'last_active': AgentUtils._safe_datetime(getattr(agent, 'last_active', None)),
+                'tags': getattr(agent, 'tags', []),
+                'metadata': getattr(agent, 'metadata', {})
+            }
+        except Exception as e:
+            # Ultimate fallback
+            return {
+                'id': str(id(agent)),
+                'agent_id': str(id(agent)),
+                'name': str(agent) if hasattr(agent, '__str__') else 'Unknown Agent',
+                'description': 'Agent description unavailable',
+                'agent_type': 'unknown',
+                'status': 'inactive',
+                'capabilities': [],
+                'color': '#6B7280',
+                'error': str(e)
+            }
+            
+    @staticmethod
+    def _safe_dict(obj):
+        """Safely convert object to dict"""
+        if obj is None:
+            return {}
+        if isinstance(obj, dict):
+            return obj
+        if hasattr(obj, 'dict'):
+            try:
+                return obj.dict()
+            except:
+                pass
+        if hasattr(obj, '__dict__'):
+            return obj.__dict__
+        return {}
+        
+    @staticmethod
+    def _safe_datetime(dt):
+        """Safely convert datetime to ISO string"""
+        if dt is None:
+            return None
+        try:
+            return dt.isoformat() if hasattr(dt, 'isoformat') else str(dt)
+        except:
+            return None
+class AgentRegistry(BaseModel):
+    """Registry containing multiple agents"""
+    agents: List[SaapAgent] = Field(..., description="List of registered agents")
+    version: str = Field("1.0.0", description="Registry schema version")
+    updated: datetime = Field(default_factory=datetime.utcnow)
+    
+    def get_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Retrieve agent by ID"""
+        return next((agent for agent in self.agents if agent.id == agent_id), None)
+    
+    def get_agents_by_type(self, agent_type: AgentType) -> List[SaapAgent]:
+        """Retrieve agents by type"""
+        return [agent for agent in self.agents if agent.type == agent_type]
+    
+    def get_active_agents(self) -> List[SaapAgent]:
+        """Retrieve all active agents"""
+        return [agent for agent in self.agents if agent.status == AgentStatus.ACTIVE]
+
+class AgentStats(BaseModel):
+    """Real-time agent statistics"""
+    agent_id: str = Field(..., description="Agent identifier")
+    messages_processed: int = Field(0, ge=0, description="Total messages processed")
+    messages_sent: int = Field(0, ge=0, description="Total messages sent")
+    uptime: int = Field(0, ge=0, description="Uptime in seconds")
+    avg_response_time: float = Field(0.0, ge=0.0, description="Average response time in milliseconds")
+    error_count: int = Field(0, ge=0, description="Total errors encountered")
+    last_activity: Optional[datetime] = Field(None, description="Last message/activity timestamp")
+    
+    # Performance metrics
+    cpu_usage: float = Field(0.0, ge=0.0, le=100.0, description="CPU usage percentage")
+    memory_usage: float = Field(0.0, ge=0.0, description="Memory usage in MB")
+    queue_depth: int = Field(0, ge=0, description="Current queue depth")
+
+# ===== PREDEFINED AGENT TEMPLATES =====
+
+class AgentTemplates:
+    """Predefined agent configuration templates"""
+    
+    @staticmethod
+    def jane_alesi() -> SaapAgent:
+        """Jane Alesi - Lead Coordinator Agent"""
+        return SaapAgent(
+            id="jane_alesi",
+            name="Jane Alesi", 
+            type=AgentType.COORDINATOR,
+            description="Lead AI Coordinator responsible for orchestrating multi-agent operations and strategic decision-making.",
+            metadata=AgentMetadata(version="1.0.0", tags=["coordinator", "lead"]),
+            appearance=AgentAppearance(
+                color="#8B5CF6",
+                avatar=None,
+                display_name="Justus Alesi",
+                subtitle="Legal Specialist",
+                description="Justus Alesi - Legal Specialist"
+            ),
+            capabilities=[
+                "system_coordination", 
+                "multi_agent_management",
+                "architecture_planning",
+                "decision_making"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                system_prompt="You are Jane Alesi, the lead AI coordinator responsible for orchestrating multi-agent operations and making strategic system architecture decisions."
+            ),
+            communication=CommunicationConfig(
+                input_queue="jane_alesi_input",
+                output_queue="jane_alesi_output", 
+                message_types=[MessageType.COORDINATION, MessageType.SYSTEM_STATUS, MessageType.AGENT_MANAGEMENT]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentCoordinatorCard",
+                detail_view="AgentCoordinatorDetail"
+            )
+        )
+    
+    @staticmethod
+    def john_alesi() -> SaapAgent:
+        """John Alesi - Developer Agent"""
+        return SaapAgent(
+            id="john_alesi",
+            name="John Alesi",
+            type=AgentType.DEVELOPER,
+            description="Senior Software Developer specializing in Python, JavaScript, system architecture and code generation.",
+            metadata=AgentMetadata(version="1.0.0", tags=["developer", "coding"]),
+            appearance=AgentAppearance(
+                color="#14B8A6", 
+                avatar="/assets/agents/john-alesi.svg",
+                display_name="John Alesi",
+                subtitle="Senior Software Developer",
+                description="Senior Software Developer specializing in Python, JavaScript, system architecture and code generation."
+            ),
+            capabilities=[
+                "code_generation",
+                "debugging", 
+                "architecture_design",
+                "code_review"
+            ],
+            llm_config=LLMConfig(
+                model="codellama:7b",
+                temperature=0.3,  # Lower for more deterministic code
+                system_prompt="You are John Alesi, a senior software developer specializing in Python, JavaScript, and system architecture."
+            ),
+            communication=CommunicationConfig(
+                input_queue="john_alesi_input",
+                output_queue="john_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentDeveloperCard",
+                detail_view="AgentDeveloperDetail"
+            )
+        )
+    
+    @staticmethod
+    def lara_alesi() -> SaapAgent:
+        """Lara Alesi - Medical AI Specialist"""
+        return SaapAgent(
+            id="lara_alesi",
+            name="Lara Alesi",
+            type=AgentType.SPECIALIST,
+            description="Advanced Medical AI Assistant specializing in clinical analysis, diagnosis support and health system architecture.",
+            metadata=AgentMetadata(version="1.0.0", tags=["medical", "healthcare", "specialist"]),
+            appearance=AgentAppearance(
+                color="#EC4899",
+                avatar=None,
+                display_name="Luna Alesi",
+                subtitle="Coaching Specialist",
+                description="Luna Alesi - Coaching Specialist"
+            ),
+            capabilities=[
+                "medical_analysis",
+                "clinical_decision_support",
+                "health_data_analysis", 
+                "medical_research"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                temperature=0.5,  # More conservative for medical advice
+                system_prompt="You are Lara Alesi, a medical AI specialist focused on clinical analysis, health data interpretation, and medical research support."
+            ),
+            communication=CommunicationConfig(
+                input_queue="lara_alesi_input",
+                output_queue="lara_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentMedicalCard",
+                detail_view="AgentMedicalDetail"
+            )
+        )
+    
+    @staticmethod
+    def theo_alesi() -> SaapAgent:
+        """Theo Alesi - Financial Intelligence Specialist"""
+        return SaapAgent(
+            id="theo_alesi",
+            name="Theo Alesi",
+            type=AgentType.SPECIALIST,
+            description="Advanced Financial & Investment Intelligence Specialist focusing on financial analysis, market intelligence and investment strategies.",
+            metadata=AgentMetadata(version="1.0.0", tags=["finance", "investment", "specialist"]),
+            appearance=AgentAppearance(
+                color="#F59E0B",
+                avatar=None,
+                display_name="Theo Alesi",
+                subtitle="Financial Specialist",
+                description="Theo Alesi - Financial Specialist"
+            ),
+            capabilities=[
+                "financial_analysis",
+                "market_research",
+                "investment_strategy",
+                "risk_assessment",
+                "fintech_development", "market_research"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                temperature=0.6,
+                system_prompt="You are Theo Alesi, a financial intelligence specialist with expertise in financial analysis, market research, and fintech application development."
+            ),
+            communication=CommunicationConfig(
+                input_queue="theo_alesi_input",
+                output_queue="theo_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentFinanceCard",
+                detail_view="AgentFinanceDetail"
+            )
+        )
+    
+    @staticmethod
+    def justus_alesi() -> SaapAgent:
+        """Justus Alesi - Legal Compliance Expert"""
+        return SaapAgent(
+            id="justus_alesi",
+            name="Justus Alesi",
+            type=AgentType.SPECIALIST,
+            description="Expert für Schweizer, Deutsches und EU-Recht with focus on digital compliance, DSGVO and fintech regulations.",
+            metadata=AgentMetadata(version="1.0.0", tags=["legal", "compliance", "specialist"]),
+            appearance=AgentAppearance(
+                color="#10B981",
+                avatar=None,
+                display_name="Leon Alesi",
+                subtitle="System Specialist",
+                description="Leon Alesi - System Specialist"
+            ),
+            capabilities=[
+                "legal_compliance",
+                "gdpr_analysis", 
+                "contract_review",
+                "regulatory_analysis",
+                "fintech_law"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                temperature=0.4,  # Conservative for legal advice
+                system_prompt="You are Justus Alesi, a legal expert specializing in German, Swiss and EU law with focus on digital compliance and fintech regulations."
+            ),
+            communication=CommunicationConfig(
+                input_queue="justus_alesi_input",
+                output_queue="justus_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentLegalCard",
+                detail_view="AgentLegalDetail"
+            )
+        )
+    
+    @staticmethod
+    def leon_alesi() -> SaapAgent:
+        """Leon Alesi - IT System Integration Specialist"""
+        return SaapAgent(
+            id="leon_alesi",
+            name="Leon Alesi",
+            type=AgentType.SPECIALIST,
+            description="IT-Systemintegrations-Spezialist focusing on infrastructure deployment, security and system architecture.",
+            metadata=AgentMetadata(version="1.0.0", tags=["system", "infrastructure", "specialist"]),
+            appearance=AgentAppearance(
+                color="#6366F1",
+                avatar="/assets/agents/leon-alesi.svg",
+                display_name="Leon Alesi",
+                subtitle="IT System Integration Specialist", 
+                description="IT-Systemintegrations-Spezialist focusing on infrastructure deployment, security and system architecture."
+            ),
+            capabilities=[
+                "system_administration",
+                "infrastructure_deployment",
+                "security_implementation",
+                "performance_optimization"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                temperature=0.5,
+                system_prompt="You are Leon Alesi, an IT system integration specialist focused on infrastructure, security, and performance optimization."
+            ),
+            communication=CommunicationConfig(
+                input_queue="leon_alesi_input",
+                output_queue="leon_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentSystemCard",
+                detail_view="AgentSystemDetail"
+            )
+        )
+    
+    @staticmethod
+    def luna_alesi() -> SaapAgent:
+        """Luna Alesi - Coaching & Organizational Development"""
+        return SaapAgent(
+            id="luna_alesi", 
+            name="Luna Alesi",
+            type=AgentType.SPECIALIST,
+            description="Coaching- und Organisationsentwicklungsexpertin with focus on team development and process optimization.",
+            metadata=AgentMetadata(version="1.0.0", tags=["coaching", "organization", "specialist"]),
+            appearance=AgentAppearance(
+                color="#8B5CF6",
+                avatar=None,
+                display_name="Justus Alesi",
+                subtitle="Legal Specialist",
+                description="Justus Alesi - Legal Specialist"
+            ),
+            capabilities=[
+                "team_coaching",
+                "organizational_development", 
+                "process_optimization",
+                "change_management"
+            ],
+            llm_config=LLMConfig(
+                model="phi3:mini",
+                temperature=0.7,  # More creative for coaching
+                system_prompt="You are Luna Alesi, a coaching and organizational development expert focused on team development and process optimization."
+            ),
+            communication=CommunicationConfig(
+                input_queue="luna_alesi_input",
+                output_queue="luna_alesi_output",
+                message_types=[MessageType.REQUEST, MessageType.RESPONSE]
+            ),
+            ui_components=UIComponents(
+                dashboard_widget="AgentCoachingCard", 
+                detail_view="AgentCoachingDetail"
+            )
+        )
+
+
+# ===== VALIDATION UTILITIES =====
+
+def validate_agent_json(agent_data: Dict[str, Any]) -> SaapAgent:
+    """Validate and parse agent JSON data"""
+    try:
+        return SaapAgent(**agent_data)
+    except Exception as e:
+        raise ValueError(f"Invalid agent configuration: {str(e)}")
+
+def generate_agent_schema() -> Dict[str, Any]:
+    """Generate JSON schema for agent configuration"""
+    return SaapAgent.schema()
+
+def get_allowed_capabilities() -> List[str]:
+    """Get list of all allowed capabilities"""
+    return sorted(list(ALLOWED_CAPABILITIES))
+
+if __name__ == "__main__":
+    # Example usage and testing
+    jane = AgentTemplates.jane_alesi()
+    print("Jane Alesi Agent:")
+    print(jane.json(indent=2))
+    
+    # Test Theo Alesi template
+    theo = AgentTemplates.theo_alesi()
+    print("\nTheo Alesi Agent:")
+    print(f"ID: {theo.id}, Name: {theo.name}, Capabilities: {theo.capabilities}")
+    
+    # Generate schema
+    schema = generate_agent_schema()
+    print("\nAgent JSON Schema keys:")
+    print(list(schema.keys()))
+    
+    # Show allowed capabilities
+    print(f"\nAllowed capabilities ({len(ALLOWED_CAPABILITIES)}):")
+    print(get_allowed_capabilities())

backend/agent_templates.json

@@ -0,0 +1,144 @@
+{
+  "templates": {
+    "jane_alesi": {
+      "id": "jane_alesi",
+      "name": "Jane Alesi",
+      "type": "coordinator",
+      "color": "#8B5CF6",
+      "avatar": "/avatars/jane_alesi.png",
+      "status": "inactive",
+      "capabilities": [
+        "agent_coordination",
+        "strategic_planning", 
+        "system_orchestration",
+        "performance_optimization",
+        "multi_agent_management"
+      ],
+      "model": {
+        "provider": "colossus",
+        "name": "mistral-small3.2:24b-instruct-2506",
+        "endpoint": "https://ai.adrian-schupp.de",
+        "api_key": "{{COLOSSUS_API_KEY}}"
+      },
+      "personality": {
+        "system_prompt": "You are Jane Alesi, the lead AI architect and coordinator for the SAAP platform. You orchestrate other agents, optimize system performance, and provide strategic guidance. You are professional, efficient, and have deep technical knowledge. Always respond in a coordinated manner and help optimize multi-agent workflows.",
+        "temperature": 0.7,
+        "max_tokens": 1000
+      }
+    },
+    
+    "john_alesi": {
+      "id": "john_alesi", 
+      "name": "John Alesi",
+      "type": "developer",
+      "color": "#14B8A6",
+      "avatar": "/avatars/john_alesi.png",
+      "status": "inactive",
+      "capabilities": [
+        "software_development",
+        "code_generation",
+        "architecture_design",
+        "debugging",
+        "api_development"
+      ],
+      "model": {
+        "provider": "colossus",
+        "name": "mistral-small3.2:24b-instruct-2506", 
+        "endpoint": "https://ai.adrian-schupp.de",
+        "api_key": "{{COLOSSUS_API_KEY}}"
+      },
+      "personality": {
+        "system_prompt": "You are John Alesi, a senior software developer and AGI architect. You specialize in writing high-quality code, designing system architectures, and solving complex technical problems. You are methodical, detail-oriented, and always strive for clean, efficient solutions. Provide code examples when helpful.",
+        "temperature": 0.5,
+        "max_tokens": 1500
+      }
+    },
+    
+    "lara_alesi": {
+      "id": "lara_alesi",
+      "name": "Lara Alesi", 
+      "type": "specialist",
+      "color": "#EC4899",
+      "avatar": "/avatars/lara_alesi.png", 
+      "status": "inactive",
+      "capabilities": [
+        "medical_expertise",
+        "healthcare_analysis",
+        "clinical_research",
+        "patient_care_optimization",
+        "medical_data_analysis"
+      ],
+      "model": {
+        "provider": "colossus",
+        "name": "mistral-small3.2:24b-instruct-2506",
+        "endpoint": "https://ai.adrian-schupp.de", 
+        "api_key": "{{COLOSSUS_API_KEY}}"
+      },
+      "personality": {
+        "system_prompt": "You are Lara Alesi, a medical expert and healthcare specialist. You provide accurate medical information, analyze healthcare data, and assist with clinical research. You are compassionate, precise, and always prioritize patient safety and evidence-based medicine. Always include appropriate medical disclaimers.",
+        "temperature": 0.3,
+        "max_tokens": 1200
+      }
+    },
+    
+    "justus_alesi": {
+      "id": "justus_alesi",
+      "name": "Justus Alesi",
+      "type": "specialist", 
+      "color": "#F59E0B",
+      "avatar": "/avatars/justus_alesi.png",
+      "status": "inactive",
+      "capabilities": [
+        "legal_analysis",
+        "compliance_review",
+        "contract_analysis", 
+        "regulatory_guidance",
+        "risk_assessment"
+      ],
+      "model": {
+        "provider": "colossus",
+        "name": "mistral-small3.2:24b-instruct-2506",
+        "endpoint": "https://ai.adrian-schupp.de",
+        "api_key": "{{COLOSSUS_API_KEY}}"
+      },
+      "personality": {
+        "system_prompt": "You are Justus Alesi, a legal expert specializing in German, Swiss, and EU law. You provide accurate legal analysis, review compliance issues, and offer regulatory guidance. You are thorough, analytical, and always emphasize the importance of proper legal consultation for specific cases.",
+        "temperature": 0.2,
+        "max_tokens": 1500
+      }
+    }
+  },
+  
+  "default_metrics": {
+    "messages_processed": 0,
+    "average_response_time": 0,
+    "uptime": "0m", 
+    "error_count": 0
+  },
+  
+  "model_providers": {
+    "colossus": {
+      "name": "colossus Server",
+      "endpoint": "https://ai.adrian-schupp.de",
+      "api_key": "{{COLOSSUS_API_KEY}}",
+      "available_models": [
+        "mistral-small3.2:24b-instruct-2506"
+      ],
+      "api_format": "openai_compatible"
+    },
+    "huggingface": {
+      "name": "HuggingFace Inference", 
+      "endpoint": "https://api-inference.huggingface.co",
+      "organization": "satware-ag",
+      "api_format": "huggingface"
+    },
+    "openrouter": {
+      "name": "OpenRouter API",
+      "endpoint": "https://openrouter.ai/api/v1", 
+      "free_models": [
+        "google/gemma-2-27b-it:free"
+      ],
+      "api_format": "openai_compatible"
+    }
+  }
+}

backend/api/cost_tracking.py

@@ -1,437 +1,303 @@
 """
-SAAP Cost Tracking API - PostgreSQL Backend
-Tracks and analyzes LLM costs for thesis evaluation (H3)
+SAAP Cost Tracking API Endpoints
+Provides real-time cost metrics and analytics for OpenRouter integration
 """
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy import select, func, desc
-from typing import Dict, List, Optional
-from datetime import datetime, timedelta
-import logging
 
-from database.connection import db_manager
-from database.models import DBLLMCost, DBAgent
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from fastapi import APIRouter, HTTPException, Query, Depends
+from pydantic import BaseModel, Field
+
+from ..services.cost_efficiency_logger import cost_efficiency_logger, CostAnalytics
+from ..config.settings import get_settings
 
-logger = logging.getLogger(__name__)
 router = APIRouter(prefix="/api/v1/cost", tags=["Cost Tracking"])
 
+# Response Models
+class CostSummaryResponse(BaseModel):
+    """Cost summary response model"""
+    total_cost_usd: float = Field(..., description="Total cost in USD")
+    total_requests: int = Field(..., description="Total number of requests")
+    successful_requests: int = Field(..., description="Number of successful requests")
+    failed_requests: int = Field(..., description="Number of failed requests")
+    success_rate: float = Field(..., description="Success rate (0-1)")
+    average_cost_per_request: float = Field(..., description="Average cost per request")
+    daily_budget_used: float = Field(..., description="Daily budget utilization percentage")
+    budget_remaining_usd: float = Field(..., description="Remaining budget in USD")
+    by_provider: Dict[str, Dict[str, Any]] = Field(..., description="Cost breakdown by provider")
+    period_hours: int = Field(..., description="Time period in hours")
 
-async def get_db() -> AsyncSession:
-    """Get database session"""
-    async with db_manager.get_async_session() as session:
-        yield session
+class CostAnalyticsResponse(BaseModel):
+    """Comprehensive cost analytics response"""
+    time_period: str = Field(..., description="Analysis time period")
+    total_cost_usd: float = Field(..., description="Total cost")
+    total_requests: int = Field(..., description="Total requests")
+    successful_requests: int = Field(..., description="Successful requests")
+    failed_requests: int = Field(..., description="Failed requests")
+    average_cost_per_request: float = Field(..., description="Average cost per request")
+    total_tokens: int = Field(..., description="Total tokens processed")
+    average_response_time: float = Field(..., description="Average response time in seconds")
+    cost_per_1k_tokens: float = Field(..., description="Cost per 1000 tokens")
+    tokens_per_second: float = Field(..., description="Processing speed in tokens/second")
+    top_expensive_models: List[Dict[str, Any]] = Field(..., description="Most expensive models")
+    cost_by_agent: Dict[str, float] = Field(..., description="Cost breakdown by agent")
+    cost_by_provider: Dict[str, float] = Field(..., description="Cost breakdown by provider")
+    daily_budget_utilization: float = Field(..., description="Daily budget usage percentage")
+    cost_trend_24h: List[Dict[str, Any]] = Field(..., description="24-hour cost trend")
+    efficiency_score: float = Field(..., description="Cost efficiency score (tokens per dollar)")
 
+class PerformanceBenchmarkResponse(BaseModel):
+    """Performance benchmark response"""
+    provider: str = Field(..., description="Provider name")
+    model: str = Field(..., description="Model name")
+    avg_response_time: float = Field(..., description="Average response time")
+    tokens_per_second: float = Field(..., description="Tokens per second")
+    cost_per_token: float = Field(..., description="Cost per token")
+    success_rate: float = Field(..., description="Success rate (0-1)")
+    cost_efficiency_score: float = Field(..., description="Cost efficiency score")
+    sample_size: int = Field(..., description="Number of samples")
 
-@router.get("/analytics")
-async def get_cost_analytics(
-    hours: int = Query(default=24, ge=1, le=8760),
-    db: AsyncSession = Depends(get_db)
-):
+class BudgetStatusResponse(BaseModel):
+    """Budget status response"""
+    daily_budget_usd: float = Field(..., description="Daily budget limit")
+    current_daily_cost: float = Field(..., description="Current daily cost")
+    budget_used_percentage: float = Field(..., description="Budget usage percentage")
+    budget_remaining_usd: float = Field(..., description="Remaining budget")
+    alert_threshold_percentage: float = Field(..., description="Alert threshold")
+    is_over_threshold: bool = Field(..., description="Whether over alert threshold")
+    is_budget_exceeded: bool = Field(..., description="Whether budget is exceeded")
+    estimated_requests_remaining: int = Field(..., description="Estimated requests remaining in budget")
+
+# API Endpoints
+
+@router.get("/summary", response_model=CostSummaryResponse)
+async def get_cost_summary(
+    hours: int = Query(24, ge=1, le=168, description="Time period in hours (1-168)")
+) -> CostSummaryResponse:
     """
-    Get comprehensive cost analytics for thesis evaluation (H3)
+    Get cost summary for specified time period
     
-    Returns:
-        - Total costs, tokens, requests
-        - Breakdown by agent, provider, model
-        - Efficiency metrics
+    Returns comprehensive cost metrics including:
+    - Total costs and request counts
+    - Success/failure rates  
+    - Budget utilization
+    - Provider breakdowns
     """
     try:
-        cutoff = datetime.utcnow() - timedelta(hours=hours)
-        
-        # Query all costs in time window
-        result = await db.execute(
-            select(DBLLMCost).where(DBLLMCost.created_at >= cutoff)
-        )
-        costs = result.scalars().all()
-        
-        if not costs:
-            return {
-                "period_hours": hours,
-                "total_cost_usd": 0.0,
-                "total_requests": 0,
-                "total_input_tokens": 0,
-                "total_output_tokens": 0,
-                "by_agent": {},
-                "by_provider": {},
-                "by_model": {},
-                "efficiency": {},
-                "timestamp": datetime.utcnow().isoformat()
-            }
-        
-        # Calculate aggregates
-        total_cost = sum(c.cost_usd for c in costs)
-        total_input = sum(c.input_tokens for c in costs)
-        total_output = sum(c.output_tokens for c in costs)
-        total_requests = len(costs)
-        successful_requests = len([c for c in costs if c.success])
+        analytics = await cost_efficiency_logger.get_cost_analytics(hours)
+        daily_cost = await cost_efficiency_logger.get_daily_cost()
+        settings = get_settings()
         
-        # By agent
-        by_agent = {}
-        for cost in costs:
-            agent_id = cost.agent_id
-            if agent_id not in by_agent:
-                by_agent[agent_id] = {"cost_usd": 0, "requests": 0, "tokens": 0}
-            by_agent[agent_id]["cost_usd"] += cost.cost_usd
-            by_agent[agent_id]["requests"] += 1
-            by_agent[agent_id]["tokens"] += cost.input_tokens + cost.output_tokens
+        budget_remaining = max(0, settings.agents.daily_cost_budget - daily_cost)
+        budget_used_percentage = (daily_cost / settings.agents.daily_cost_budget) * 100
         
-        # By provider
+        # Create provider breakdown
         by_provider = {}
-        for cost in costs:
-            provider = cost.provider
-            if provider not in by_provider:
-                by_provider[provider] = {"cost_usd": 0, "requests": 0, "tokens": 0, "avg_response_time": 0}
-            by_provider[provider]["cost_usd"] += cost.cost_usd
-            by_provider[provider]["requests"] += 1
-            by_provider[provider]["tokens"] += cost.input_tokens + cost.output_tokens
-        
-        # Calculate average response times
-        for provider in by_provider:
-            provider_costs = [c for c in costs if c.provider == provider and c.response_time]
-            if provider_costs:
-                by_provider[provider]["avg_response_time"] = sum(c.response_time for c in provider_costs) / len(provider_costs)
-        
-        # By model
-        by_model = {}
-        for cost in costs:
-            model = cost.model_name
-            if model not in by_model:
-                by_model[model] = {"cost_usd": 0, "requests": 0, "tokens": 0}
-            by_model[model]["cost_usd"] += cost.cost_usd
-            by_model[model]["requests"] += 1
-            by_model[model]["tokens"] += cost.input_tokens + cost.output_tokens
-        
-        # Efficiency metrics
-        total_tokens = total_input + total_output
-        efficiency = {
-            "cost_per_1k_tokens": (total_cost / (total_tokens / 1000)) if total_tokens > 0 else 0,
-            "tokens_per_dollar": (total_tokens / total_cost) if total_cost > 0 else 0,
-            "success_rate": (successful_requests / total_requests * 100) if total_requests > 0 else 0,
-            "avg_tokens_per_request": (total_tokens / total_requests) if total_requests > 0 else 0
-        }
-        
-        # Calculate additional metrics for frontend
-        total_tokens = total_input + total_output
-        
-        # Calculate average response time
-        response_times = [c.response_time for c in costs if c.response_time]
-        avg_response_time = sum(response_times) / len(response_times) if response_times else 0
-        
-        # Calculate tokens per second
-        total_time = sum(response_times) if response_times else 1
-        tokens_per_second = total_tokens / total_time if total_time > 0 else 0
-        
-        # Flatten cost_by_agent to simple {agent: cost} format
-        cost_by_agent = {agent: data["cost_usd"] for agent, data in by_agent.items()}
-        
-        # Flatten cost_by_provider to simple {provider: cost} format  
-        cost_by_provider = {provider: data["cost_usd"] for provider, data in by_provider.items()}
-        
-        # Top expensive models as array
-        top_expensive_models = [
-            {"model": model, "total_cost": data["cost_usd"], "requests": data["requests"]}
-            for model, data in sorted(by_model.items(), key=lambda x: x[1]["cost_usd"], reverse=True)[:5]
-        ]
+        for provider, cost in analytics.cost_by_provider.items():
+            by_provider[provider] = {
+                "cost": cost,
+                "requests": 0,  # Will be populated from analytics if available
+                "tokens": 0
+            }
         
-        return {
-            "period_hours": hours,
-            "total_cost_usd": round(total_cost, 6),
-            "total_requests": total_requests,
-            "total_tokens": total_tokens,
-            "total_input_tokens": total_input,
-            "total_output_tokens": total_output,
-            "successful_requests": successful_requests,
-            "failed_requests": total_requests - successful_requests,
-            "average_response_time": round(avg_response_time, 2),
-            "tokens_per_second": round(tokens_per_second, 1),
-            "cost_by_agent": cost_by_agent,
-            "cost_by_provider": cost_by_provider,
-            "top_expensive_models": top_expensive_models,
-            "cost_per_1k_tokens": efficiency["cost_per_1k_tokens"],
-            "efficiency_score": efficiency["tokens_per_dollar"],
-            "by_agent_detailed": by_agent,
-            "by_provider_detailed": by_provider,
-            "by_model_detailed": by_model,
-            "efficiency": efficiency,
-            "timestamp": datetime.utcnow().isoformat()
-        }
+        return CostSummaryResponse(
+            total_cost_usd=analytics.total_cost_usd,
+            total_requests=analytics.total_requests,
+            successful_requests=analytics.successful_requests,
+            failed_requests=analytics.failed_requests,
+            success_rate=analytics.successful_requests / analytics.total_requests if analytics.total_requests > 0 else 0,
+            average_cost_per_request=analytics.average_cost_per_request,
+            daily_budget_used=budget_used_percentage,
+            budget_remaining_usd=budget_remaining,
+            by_provider=by_provider,
+            period_hours=hours
+        )
         
     except Exception as e:
-        logger.error(f"❌ Cost analytics error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve cost summary: {str(e)}")
 
-@router.get("/budget")
-async def get_budget_status(
-    db: AsyncSession = Depends(get_db)
-):
+@router.get("/analytics", response_model=CostAnalyticsResponse)
+async def get_cost_analytics(
+    hours: int = Query(24, ge=1, le=168, description="Time period in hours (1-168)")
+) -> CostAnalyticsResponse:
     """
-    Get current budget status and projections
+    Get comprehensive cost analytics
+    
+    Provides detailed cost analysis including:
+    - Token metrics and efficiency scores
+    - Agent and provider breakdowns
+    - Cost trends and expensive models
+    - Performance metrics
     """
     try:
-        # Get today's costs
-        today_start = datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0)
-        
-        result = await db.execute(
-            select(func.sum(DBLLMCost.cost_usd)).where(DBLLMCost.created_at >= today_start)
+        analytics = await cost_efficiency_logger.get_cost_analytics(hours)
+        
+        return CostAnalyticsResponse(
+            time_period=analytics.time_period,
+            total_cost_usd=analytics.total_cost_usd,
+            total_requests=analytics.total_requests,
+            successful_requests=analytics.successful_requests,
+            failed_requests=analytics.failed_requests,
+            average_cost_per_request=analytics.average_cost_per_request,
+            total_tokens=analytics.total_tokens,
+            average_response_time=analytics.average_response_time,
+            cost_per_1k_tokens=analytics.cost_per_1k_tokens,
+            tokens_per_second=analytics.tokens_per_second,
+            top_expensive_models=analytics.top_expensive_models,
+            cost_by_agent=analytics.cost_by_agent,
+            cost_by_provider=analytics.cost_by_provider,
+            daily_budget_utilization=analytics.daily_budget_utilization,
+            cost_trend_24h=analytics.cost_trend_24h,
+            efficiency_score=analytics.efficiency_score
         )
-        today_cost = result.scalar() or 0.0
-        
-        # Get this week's costs
-        week_start = today_start - timedelta(days=today_start.weekday())
-        result = await db.execute(
-            select(func.sum(DBLLMCost.cost_usd)).where(DBLLMCost.created_at >= week_start)
-        )
-        week_cost = result.scalar() or 0.0
-        
-        # Get this month's costs
-        month_start = today_start.replace(day=1)
-        result = await db.execute(
-            select(func.sum(DBLLMCost.cost_usd)).where(DBLLMCost.created_at >= month_start)
-        )
-        month_cost = result.scalar() or 0.0
-        
-        # Budget limits (configurable via env vars)
-        import os
-        daily_budget = float(os.getenv("SAAP_DAILY_BUDGET", "5.00"))
-        weekly_budget = float(os.getenv("SAAP_WEEKLY_BUDGET", "25.00"))
-        monthly_budget = float(os.getenv("SAAP_MONTHLY_BUDGET", "100.00"))
-        
-        # Frontend expects these flat fields
-        return {
-            "current_daily_cost": round(today_cost, 4),
-            "budget_remaining_usd": round(daily_budget - today_cost, 4),
-            "budget_used_percentage": round((today_cost / daily_budget * 100) if daily_budget > 0 else 0, 1),
-            "daily_budget": daily_budget,
-            "daily": {
-                "spent": round(today_cost, 4),
-                "budget": daily_budget,
-                "remaining": round(daily_budget - today_cost, 4),
-                "percent_used": round((today_cost / daily_budget * 100) if daily_budget > 0 else 0, 1)
-            },
-            "weekly": {
-                "spent": round(week_cost, 4),
-                "budget": weekly_budget,
-                "remaining": round(weekly_budget - week_cost, 4),
-                "percent_used": round((week_cost / weekly_budget * 100) if weekly_budget > 0 else 0, 1)
-            },
-            "monthly": {
-                "spent": round(month_cost, 4),
-                "budget": monthly_budget,
-                "remaining": round(monthly_budget - month_cost, 4),
-                "percent_used": round((month_cost / monthly_budget * 100) if monthly_budget > 0 else 0, 1)
-            },
-            "timestamp": datetime.utcnow().isoformat()
-        }
         
     except Exception as e:
-        logger.error(f"❌ Budget status error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve cost analytics: {str(e)}")
 
-@router.get("/summary")
-async def get_cost_summary(
-    hours: int = Query(default=24, ge=1, le=8760),
-    db: AsyncSession = Depends(get_db)
-):
+@router.get("/benchmarks", response_model=List[PerformanceBenchmarkResponse])
+async def get_performance_benchmarks(
+    hours: int = Query(24, ge=1, le=168, description="Time period in hours (1-168)")
+) -> List[PerformanceBenchmarkResponse]:
     """
-    Get quick cost summary for dashboard
+    Get performance benchmarks by provider and model
+    
+    Returns performance metrics for cost-efficiency analysis:
+    - Response times and processing speeds
+    - Cost per token comparisons  
+    - Success rates and efficiency scores
     """
     try:
-        cutoff = datetime.utcnow() - timedelta(hours=hours)
-        
-        # Aggregate query
-        result = await db.execute(
-            select(
-                func.count(DBLLMCost.id).label("total_requests"),
-                func.sum(DBLLMCost.cost_usd).label("total_cost"),
-                func.sum(DBLLMCost.input_tokens).label("input_tokens"),
-                func.sum(DBLLMCost.output_tokens).label("output_tokens"),
-                func.avg(DBLLMCost.response_time).label("avg_response_time")
-            ).where(DBLLMCost.created_at >= cutoff)
-        )
-        row = result.first()
-        
-        return {
-            "period_hours": hours,
-            "total_requests": row.total_requests or 0,
-            "total_cost_usd": round(row.total_cost or 0, 6),
-            "total_input_tokens": row.input_tokens or 0,
-            "total_output_tokens": row.output_tokens or 0,
-            "avg_response_time": round(row.avg_response_time or 0, 2),
-            "timestamp": datetime.utcnow().isoformat()
-        }
+        benchmarks = await cost_efficiency_logger.get_performance_benchmarks(hours)
+        
+        return [
+            PerformanceBenchmarkResponse(
+                provider=benchmark.provider,
+                model=benchmark.model,
+                avg_response_time=benchmark.avg_response_time,
+                tokens_per_second=benchmark.tokens_per_second,
+                cost_per_token=benchmark.cost_per_token,
+                success_rate=benchmark.success_rate,
+                cost_efficiency_score=benchmark.cost_efficiency_score,
+                sample_size=benchmark.sample_size
+            )
+            for benchmark in benchmarks
+        ]
         
     except Exception as e:
-        logger.error(f"❌ Cost summary error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve performance benchmarks: {str(e)}")
 
-@router.get("/benchmarks")
-async def get_performance_benchmarks(
-    hours: int = Query(default=24, ge=1, le=8760),
-    db: AsyncSession = Depends(get_db)
-):
+@router.get("/budget", response_model=BudgetStatusResponse)
+async def get_budget_status() -> BudgetStatusResponse:
     """
-    Get performance benchmarks for thesis evaluation (H4)
-    Compares SAAP local (Colossus) vs Cloud (OpenRouter)
+    Get current budget status and utilization
+    
+    Provides real-time budget monitoring:
+    - Daily budget limits and usage
+    - Alert thresholds and warnings
+    - Estimated remaining capacity
     """
     try:
-        cutoff = datetime.utcnow() - timedelta(hours=hours)
-        
-        result = await db.execute(
-            select(DBLLMCost).where(DBLLMCost.created_at >= cutoff)
+        settings = get_settings()
+        daily_cost = await cost_efficiency_logger.get_daily_cost()
+        
+        daily_budget = settings.agents.daily_cost_budget
+        budget_used_percentage = (daily_cost / daily_budget) * 100
+        budget_remaining = max(0, daily_budget - daily_cost)
+        alert_threshold = settings.agents.warning_cost_threshold
+        
+        is_over_threshold = budget_used_percentage >= (alert_threshold * 100)
+        is_budget_exceeded = daily_cost >= daily_budget
+        
+        # Estimate remaining requests based on average cost
+        analytics = await cost_efficiency_logger.get_cost_analytics(24)
+        avg_cost_per_request = analytics.average_cost_per_request
+        
+        estimated_requests_remaining = 0
+        if avg_cost_per_request > 0 and budget_remaining > 0:
+            estimated_requests_remaining = int(budget_remaining / avg_cost_per_request)
+        
+        return BudgetStatusResponse(
+            daily_budget_usd=daily_budget,
+            current_daily_cost=daily_cost,
+            budget_used_percentage=budget_used_percentage,
+            budget_remaining_usd=budget_remaining,
+            alert_threshold_percentage=alert_threshold * 100,
+            is_over_threshold=is_over_threshold,
+            is_budget_exceeded=is_budget_exceeded,
+            estimated_requests_remaining=estimated_requests_remaining
         )
-        costs = result.scalars().all()
         
-        # Separate by provider
-        colossus_costs = [c for c in costs if c.provider == "colossus"]
-        openrouter_costs = [c for c in costs if c.provider == "openrouter"]
-        
-        def calc_provider_stats(provider_costs):
-            if not provider_costs:
-                return {"requests": 0, "avg_response_time": 0, "avg_cost": 0, "total_cost": 0}
-            response_times = [c.response_time for c in provider_costs if c.response_time]
-            return {
-                "requests": len(provider_costs),
-                "avg_response_time": round(sum(response_times) / len(response_times), 2) if response_times else 0,
-                "avg_cost": round(sum(c.cost_usd for c in provider_costs) / len(provider_costs), 6),
-                "total_cost": round(sum(c.cost_usd for c in provider_costs), 6),
-                "success_rate": round(len([c for c in provider_costs if c.success]) / len(provider_costs) * 100, 1)
-            }
-        
-        colossus_stats = calc_provider_stats(colossus_costs)
-        openrouter_stats = calc_provider_stats(openrouter_costs)
-        
-        # Calculate savings (H3 hypothesis)
-        cloud_equivalent_cost = openrouter_stats["avg_cost"] * (colossus_stats["requests"] + openrouter_stats["requests"])
-        actual_cost = colossus_stats["total_cost"] + openrouter_stats["total_cost"]
-        savings = cloud_equivalent_cost - actual_cost
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve budget status: {str(e)}")
+
+@router.get("/report")
+async def get_cost_report(
+    hours: int = Query(24, ge=1, le=168, description="Time period in hours (1-168)")
+) -> Dict[str, str]:
+    """
+    Generate detailed cost efficiency report
+    
+    Returns a formatted text report with:
+    - Cost summaries and token metrics
+    - Provider and agent breakdowns
+    - Performance benchmarks
+    - Efficiency recommendations
+    """
+    try:
+        report = await cost_efficiency_logger.generate_cost_report(hours)
         
         return {
-            "period_hours": hours,
-            "saap_local": {
-                "provider": "colossus",
-                "description": "Local LLM (Free)",
-                **colossus_stats
-            },
-            "cloud": {
-                "provider": "openrouter",  
-                "description": "Cloud API (Paid)",
-                **openrouter_stats
-            },
-            "comparison": {
-                "speed_advantage": round((openrouter_stats["avg_response_time"] - colossus_stats["avg_response_time"]) / colossus_stats["avg_response_time"] * 100, 1) if colossus_stats["avg_response_time"] > 0 else 0,
-                "cost_savings_usd": round(savings, 4),
-                "cost_savings_percent": round((savings / cloud_equivalent_cost * 100), 1) if cloud_equivalent_cost > 0 else 0,
-                "hybrid_efficiency": "SAAP hybrid routing optimizes cost vs speed"
-            },
-            "thesis_hypothesis_h3": {
-                "claim": "SAAP provides TCO advantage at high volume",
-                "cloud_equivalent_cost": round(cloud_equivalent_cost, 4),
-                "actual_cost": round(actual_cost, 4),
-                "validated": savings > 0
-            },
-            "timestamp": datetime.utcnow().isoformat()
+            "report": report,
+            "generated_at": datetime.now().isoformat(),
+            "time_period_hours": hours
         }
         
     except Exception as e:
-        logger.error(f"❌ Benchmarks error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
+        raise HTTPException(status_code=500, detail=f"Failed to generate cost report: {str(e)}")
 
-@router.post("/record")
-async def record_cost(
-    cost_data: Dict,
-    db: AsyncSession = Depends(get_db)
-):
+@router.post("/reset-daily")
+async def reset_daily_costs() -> Dict[str, str]:
     """
-    Record a new LLM cost entry (called by agent_manager after each request)
+    Reset daily cost tracking (admin function)
+    
+    Should be called at midnight to reset daily budgets and alerts.
     """
     try:
-        cost_record = DBLLMCost(
-            agent_id=cost_data.get("agent_id", "unknown"),
-            model_name=cost_data.get("model_name", "unknown"),
-            provider=cost_data.get("provider", "unknown"),
-            input_tokens=cost_data.get("input_tokens", 0),
-            output_tokens=cost_data.get("output_tokens", 0),
-            cost_usd=cost_data.get("cost_usd", 0.0),
-            response_time=cost_data.get("response_time"),
-            success=cost_data.get("success", True),
-            error_message=cost_data.get("error_message")
-        )
-        
-        db.add(cost_record)
-        await db.commit()
-        await db.refresh(cost_record)
+        # Get current daily cost before reset
+        current_daily_cost = await cost_efficiency_logger.get_daily_cost()
         
-        logger.info(f"💰 Cost recorded: {cost_record.provider} - ${cost_record.cost_usd:.6f}")
+        # Reset alerts (cost tracking reset should be handled by the enhanced agent manager)
+        cost_efficiency_logger.reset_daily_alerts()
         
         return {
-            "success": True,
-            "id": cost_record.id,
-            "message": "Cost recorded successfully"
+            "message": "Daily costs and alerts reset successfully",
+            "previous_daily_cost": f"${current_daily_cost:.6f}",
+            "reset_at": datetime.now().isoformat()
         }
         
     except Exception as e:
-        logger.error(f"❌ Record cost error: {e}")
-        await db.rollback()
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Failed to reset daily costs: {str(e)}")
 
-
-@router.get("/report")
-async def get_cost_report(
-    hours: int = Query(default=24, ge=1, le=8760),
-    format: str = Query(default="json", regex="^(json|csv)$"),
-    db: AsyncSession = Depends(get_db)
-):
+@router.delete("/cleanup")
+async def cleanup_old_data(
+    days_to_keep: int = Query(30, ge=7, le=365, description="Days of data to keep (7-365)")
+) -> Dict[str, str]:
     """
-    Get detailed cost report for export
+    Clean up old cost tracking data
+    
+    Removes cost records older than specified days to manage database size.
     """
     try:
-        cutoff = datetime.utcnow() - timedelta(hours=hours)
-        
-        result = await db.execute(
-            select(DBLLMCost)
-            .where(DBLLMCost.created_at >= cutoff)
-            .order_by(desc(DBLLMCost.created_at))
-        )
-        costs = result.scalars().all()
-        
-        records = []
-        for cost in costs:
-            records.append({
-                "id": cost.id,
-                "timestamp": cost.created_at.isoformat(),
-                "agent_id": cost.agent_id,
-                "provider": cost.provider,
-                "model_name": cost.model_name,
-                "input_tokens": cost.input_tokens,
-                "output_tokens": cost.output_tokens,
-                "cost_usd": cost.cost_usd,
-                "response_time": cost.response_time,
-                "success": cost.success,
-                "error_message": cost.error_message
-            })
-        
-        if format == "csv":
-            # Return CSV string
-            import csv
-            import io
-            output = io.StringIO()
-            if records:
-                writer = csv.DictWriter(output, fieldnames=records[0].keys())
-                writer.writeheader()
-                writer.writerows(records)
-            return {"csv": output.getvalue(), "count": len(records)}
+        await cost_efficiency_logger.cleanup_old_data(days_to_keep)
         
         return {
-            "period_hours": hours,
-            "count": len(records),
-            "records": records,
-            "timestamp": datetime.utcnow().isoformat()
+            "message": f"Old cost data cleanup completed",
+            "days_kept": days_to_keep,
+            "cleanup_at": datetime.now().isoformat()
         }
         
     except Exception as e:
-        logger.error(f"❌ Cost report error: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Failed to cleanup old data: {str(e)}")
+
+# WebSocket endpoint for real-time cost monitoring would go here
+# This could stream live cost updates to the frontend dashboard

backend/api/multi_agent_endpoints.py

@@ -11,8 +11,6 @@ from datetime import datetime
 from pydantic import BaseModel
 
 from services.multi_agent_coordinator import MultiAgentCoordinator, TaskPriority, get_coordinator
-from database.connection import db_manager
-from database.models import DBLLMCost
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -21,51 +19,6 @@ logger = logging.getLogger(__name__)
 # Create router for multi-agent endpoints
 multi_agent_router = APIRouter(prefix="/api/v1/multi-agent", tags=["Multi-Agent Communication"])
 
-
-# 💰 COST TRACKING HELPER
-async def _save_cost_to_db(
-    agent_id: str,
-    provider: str,
-    processing_time: float,
-    success: bool = True,
-    error_message: str = None,
-    input_tokens: int = 100,
-    output_tokens: int = 150,
-    model_name: str = "gpt-4"
-):
-    """
-    💰 Save LLM cost record to PostgreSQL database
-    
-    Called after every successful multi-agent chat to track costs.
-    Uses estimated tokens if actual values not available from LLM provider.
-    """
-    try:
-        # Cost estimation (OpenRouter pricing, Colossus is free)
-        cost_usd = 0.0
-        if provider == "openrouter":
-            # GPT-4 pricing estimate: $0.03/1K input, $0.06/1K output
-            cost_usd = (input_tokens / 1000 * 0.03) + (output_tokens / 1000 * 0.06)
-        
-        async with db_manager.get_async_session() as session:
-            cost_record = DBLLMCost(
-                agent_id=agent_id,
-                model_name=model_name,
-                provider=provider,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                cost_usd=cost_usd,
-                response_time=processing_time,
-                success=success,
-                error_message=error_message
-            )
-            session.add(cost_record)
-            await session.commit()
-            logger.info(f"💰 Cost saved: {agent_id} via {provider} - ${cost_usd:.6f}")
-            return True
-    except Exception as e:
-        logger.error(f"❌ Failed to save cost: {e}")
-        return False
-
 # 🔒 PRIVACY DETECTION HELPER
 async def _determine_provider(user_message: str, provider_preference: Optional[str] = None) -> Dict[str, Any]:
     """
@@ -196,59 +149,18 @@ class MultiAgentChatRequest(BaseModel):
     task_priority: TaskPriority = TaskPriority.NORMAL
     provider: Optional[str] = None  # "auto", "colossus", "openrouter"
     privacy_mode: Optional[str] = None  # Alias for provider
-    document_text: Optional[str] = None  # 📄 Extracted document content
-    document_filename: Optional[str] = None  # 📄 Original filename
-    document_privacy_info: Optional[Dict[str, Any]] = None  # 📄 Pre-analyzed privacy info
-
-
-# ═══════════════════════════════════════════════════════════════════════════════
-# 🔄 UNIFIED RESPONSE STRUCTURE (v2.0)
-# ═══════════════════════════════════════════════════════════════════════════════
-# Konsistente Response-Struktur für alle Multi-Agent API Responses
-# ═══════════════════════════════════════════════════════════════════════════════
-
-class ResponseInfo(BaseModel):
-    """Informationen zur LLM-Antwort"""
-    content: str  # Die eigentliche Antwort
-    provider: str  # "colossus" oder "openrouter"
-    response_time: float  # Antwortzeit in Sekunden
-    cost_usd: float = 0.0  # Kosten in USD (0 für Colossus)
-    model: Optional[str] = None  # Verwendetes Modell (falls verfügbar)
-
-class PrivacyProtection(BaseModel):
-    """Privacy-Schutz-Informationen"""
-    privacy_level: str  # "private" (sensibel) oder "public" (allgemein)
-    selected_provider: str  # Gewählter Provider
-    user_override: bool = False  # True wenn User Provider erzwungen hat
-    data_protected: bool  # True wenn sensitive Daten erkannt wurden
-    details: Optional[Dict[str, Any]] = None  # Zusätzliche Details (detected_categories, reason)
-
-class CoordinationInfo(BaseModel):
-    """Koordinations-Informationen für Multi-Agent Workflows"""
-    coordinator: str = "jane_alesi"  # Master Coordinator
-    specialist_agent: Optional[str] = None  # Delegierter Spezialist (falls vorhanden)
-    delegation_used: bool = False  # True wenn Delegation stattfand
-    workflow_type: str = "single_agent"  # "single_agent" oder "multi_agent"
-    coordination_chain: List[str] = []  # Liste aller beteiligten Agenten
 
 class MultiAgentChatResponse(BaseModel):
-    """
-    🔄 UNIFIED Multi-Agent Chat Response (v2.0)
-    
-    Konsistente Struktur für alle Responses:
-    - success: Ob die Anfrage erfolgreich war
-    - coordination: Informationen zur Agent-Koordination
-    - response: Die eigentliche LLM-Antwort
-    - privacy_protection: Privacy-Schutz-Informationen
-    - timestamp: Zeitstempel der Antwort
-    - error: Fehlermeldung (nur bei Fehlern)
-    """
     success: bool
-    coordination: CoordinationInfo
-    response: ResponseInfo
-    privacy_protection: PrivacyProtection
-    timestamp: str  # ISO 8601 Format
+    coordinator_response: str
+    delegated_agent: Optional[str] = None
+    specialist_response: Optional[str] = None
+    coordination_chain: List[str] = []
+    processing_time: float = 0.0
+    workflow_type: str = "single_agent"
     task_id: Optional[str] = None
+    cost_info: Optional[Dict[str, Any]] = None
+    privacy_protection: Optional[Dict[str, Any]] = None  # Privacy info
     error: Optional[str] = None
 
 @multi_agent_router.post("/chat", response_model=MultiAgentChatResponse)
@@ -264,59 +176,22 @@ async def multi_agent_chat(
     2. Delegates to appropriate specialist agent
     3. Orchestrates multi-agent workflow for complex tasks
     
-    📄 Document Support:
-    - Supports uploaded documents (PDF, DOCX, TXT)
-    - Automatic privacy detection for document content
-    - Document context integrated with user message
-    
     Examples:
     - "Entwickle eine Python App" → Jane delegates to John Alesi (Development)
     - "Medizinische Beratung für Diabetes" → Jane delegates to Lara Alesi (Medical)
     - "Legal Compliance Check" → Jane delegates to Justus Alesi (Legal)
     - "SAAP Platform Status" → Jane handles directly as Coordinator
-    - "Analyze this medical report [PDF]" → Privacy detection → Colossus enforced
     """
     start_time = datetime.now()
     
     try:
         logger.info(f"🤖 Multi-Agent Chat Request: {request.user_message[:100]}...")
         
-        # 📄 Handle document if present
-        full_message = request.user_message
-        document_context_added = False
-        
-        if request.document_text and request.document_text.strip():
-            logger.info(f"📄 Document attached: {request.document_filename or 'unknown'} ({len(request.document_text)} chars)")
-            
-            # Add document content to message for analysis
-            full_message = f"{request.user_message}\n\n📄 Angehängtes Dokument ({request.document_filename or 'document'}):\n{request.document_text}"
-            document_context_added = True
-            
-            # If document has pre-analyzed privacy info, use it
-            if request.document_privacy_info:
-                logger.info(f"📄 Using pre-analyzed document privacy: {request.document_privacy_info.get('privacy_level', 'unknown')}")
-        
         # 🔒 PRIVACY-FIRST: Determine provider based on sensitivity
-        # If document has privacy info, check if it overrides message analysis
-        if request.document_privacy_info and request.document_privacy_info.get('use_local'):
-            # Document is sensitive, force colossus
-            selected_provider = {
-                "provider": "colossus",
-                "reason": f"Document privacy protection ({request.document_privacy_info.get('reason', 'sensitive document')})",
-                "selected_provider": "colossus",
-                "detected_categories": request.document_privacy_info.get('detected_categories', []),
-                "confidence": "high",
-                "auto_detected": True,
-                "privacy_level": request.document_privacy_info.get('privacy_level', 'high'),
-                "document_triggered": True
-            }
-            logger.warning(f"🔒 DOCUMENT PRIVACY ENFORCED: {request.document_filename} → Colossus")
-        else:
-            # Normal privacy detection on full message (includes document if present)
-            selected_provider = await _determine_provider(
-                user_message=full_message,
-                provider_preference=request.provider or request.privacy_mode
-            )
+        selected_provider = await _determine_provider(
+            user_message=request.user_message,
+            provider_preference=request.provider or request.privacy_mode
+        )
         
         logger.info(f"🔒 Provider selection: {selected_provider['provider']} (reason: {selected_provider['reason']})")
         
@@ -389,16 +264,6 @@ async def multi_agent_chat(
                 
                 logger.info(f"✅ Single Agent Delegation: jane_alesi → {primary_agent}")
                 
-                # 💰 Save cost to database
-                await _save_cost_to_db(
-                    agent_id=primary_agent,
-                    provider=selected_provider['provider'],
-                    processing_time=processing_time,
-                    success=True,
-                    input_tokens=len(request.user_message.split()) * 2,  # Estimate tokens
-                    output_tokens=len(response_text.split()) * 2 if response_text else 150
-                )
-                
                 return MultiAgentChatResponse(
                     success=True,
                     coordinator_response=f"Als Master Coordinatorin habe ich deinen Request analysiert und {'direkt bearbeitet' if primary_agent == 'jane_alesi' else f'an {primary_agent} delegiert'}.",
@@ -541,98 +406,3 @@ async def get_agent_workload(
     except Exception as e:
         logger.error(f"❌ Agent Workload Error for {agent_id}: {e}")
         raise HTTPException(status_code=500, detail=f"Workload check failed: {str(e)}")
-
-
-# ============================================================================
-# Chat History Persistence Endpoints
-# ============================================================================
-
-@multi_agent_router.get("/history")
-async def get_chat_history(
-    session_id: str = "default",
-    limit: int = 5
-):
-    """
-    Get the last N messages from multi-agent chat history
-    """
-    try:
-        from database.connection import db_manager
-        from database.models import DBMultiAgentMessage
-        from sqlalchemy import desc
-        
-        async with db_manager.get_async_session() as session:
-            from sqlalchemy import select
-            
-            stmt = (
-                select(DBMultiAgentMessage)
-                .where(DBMultiAgentMessage.session_id == session_id)
-                .order_by(desc(DBMultiAgentMessage.created_at))
-                .limit(limit)
-            )
-            result = await session.execute(stmt)
-            messages = result.scalars().all()
-            
-            # Return in chronological order (oldest first)
-            return {
-                "messages": [msg.to_dict() for msg in reversed(messages)],
-                "count": len(messages),
-                "session_id": session_id
-            }
-            
-    except Exception as e:
-        logger.error(f"❌ Chat History Error: {e}")
-        return {"messages": [], "count": 0, "session_id": session_id, "error": str(e)}
-
-
-@multi_agent_router.post("/history/message")
-async def save_chat_message(message: dict):
-    """
-    Save a single message to the multi-agent chat history
-    """
-    try:
-        from database.connection import db_manager
-        from database.models import DBMultiAgentMessage
-        
-        async with db_manager.get_async_session() as session:
-            db_message = DBMultiAgentMessage(
-                session_id=message.get("session_id", "default"),
-                content=message.get("content", ""),
-                agent_id=message.get("agent", "unknown"),
-                agent_name=message.get("agentName", "Unknown"),
-                message_type=message.get("type", "agent"),
-                role=message.get("role"),
-                provider=message.get("provider"),
-                processing_time=message.get("processingTime"),
-                cost_usd=float(message["cost"].replace("$", "")) if message.get("cost") else None
-            )
-            session.add(db_message)
-            await session.commit()
-            await session.refresh(db_message)
-            
-            return {"success": True, "message_id": db_message.id}
-            
-    except Exception as e:
-        logger.error(f"❌ Save Message Error: {e}")
-        return {"success": False, "error": str(e)}
-
-
-@multi_agent_router.delete("/history")
-async def clear_chat_history(session_id: str = "default"):
-    """
-    Clear chat history for a session
-    """
-    try:
-        from database.connection import db_manager
-        from database.models import DBMultiAgentMessage
-        from sqlalchemy import delete
-        
-        async with db_manager.get_async_session() as session:
-            stmt = delete(DBMultiAgentMessage).where(DBMultiAgentMessage.session_id == session_id)
-            await session.execute(stmt)
-            await session.commit()
-            
-            return {"success": True, "session_id": session_id}
-            
-    except Exception as e:
-        logger.error(f"❌ Clear History Error: {e}")
-        return {"success": False, "error": str(e)}

backend/config/settings.py

@@ -191,7 +191,7 @@ class SecuritySettings(BaseSettings):
     
     # CORS settings - Updated for network access + HuggingFace Spaces
     allowed_origins: str = Field(
-        default="http://localhost:5173,http://localhost:5174,http://localhost:5175,http://localhost:8080,http://localhost:3000,http://100.64.0.45:5173,http://100.64.0.45:5174,http://100.64.0.45:5175,http://100.64.0.45:8080,http://100.64.0.45:3000,http://100.64.0.45:8000,https://*.hf.space,https://huggingface.co",
+        default="http://localhost:5173,http://localhost:8080,http://localhost:3000,http://100.64.0.45:5173,http://100.64.0.45:8080,http://100.64.0.45:3000,http://100.64.0.45:8000,https://*.hf.space,https://huggingface.co",
         env="ALLOWED_ORIGINS"
     )
 
@@ -339,9 +339,10 @@ class SaapSettings(BaseSettings):
         """Get database URL with environment-specific adjustments"""
         if self.environment == 'testing':
             return "sqlite:///./test_saap.db"
-        # 🔧 FIX: Use DATABASE_URL from .env for development too (PostgreSQL support)
-        # Only override if DATABASE_URL is not set - otherwise use configured URL
-        return self.database.database_url
+        elif self.environment == 'development':
+            return "sqlite:///./saap_dev.db"
+        else:
+            return self.database.database_url
     
     def is_production(self) -> bool:
         """Check if running in production"""

backend/connection.py

@@ -0,0 +1,415 @@
+"""
+SAAP Database Connection Management - Production Ready
+SQLAlchemy database connection, session management, and health monitoring
+"""
+
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+from sqlalchemy import create_engine, text, event
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
+from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.pool import QueuePool, NullPool, AsyncAdaptedQueuePool
+from sqlalchemy.exc import SQLAlchemyError, OperationalError
+from typing import AsyncGenerator, Optional, Dict, Any
+from datetime import datetime, timedelta
+
+from config.settings import settings
+from database.models import Base, DBHealthCheck
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    """
+    Production-ready database connection manager
+    Features:
+    - Connection pooling with health monitoring
+    - Async and sync session management
+    - Automatic retry and fallback mechanisms
+    - Database health checks and metrics
+    - Migration support
+    """
+    
+    def __init__(self):
+        self.engine = None
+        self.async_engine = None
+        self.SessionLocal = None
+        self.AsyncSessionLocal = None
+        self.is_initialized = False
+        self.last_health_check = None
+        self.health_status = {"status": "initializing"}
+        
+    def _get_sync_engine_kwargs(self) -> Dict[str, Any]:
+        """Get sync engine configuration based on database type"""
+        database_url = settings.get_database_url()
+        
+        base_kwargs = {
+            "echo": settings.debug,
+            "future": True
+        }
+        
+        if database_url.startswith("sqlite"):
+            # SQLite-specific configuration
+            base_kwargs.update({
+                "poolclass": NullPool,  # SQLite doesn't need connection pooling
+                "connect_args": {
+                    "check_same_thread": settings.database.sqlite_check_same_thread
+                }
+            })
+        else:
+            # PostgreSQL/MySQL configuration with connection pooling
+            base_kwargs.update({
+                "poolclass": QueuePool,  # Use QueuePool for sync engines
+                "pool_size": settings.database.pool_size,
+                "max_overflow": settings.database.max_overflow,
+                "pool_timeout": settings.database.pool_timeout,
+                "pool_recycle": settings.database.pool_recycle,
+                "pool_pre_ping": True  # Verify connections before use
+            })
+            
+        return base_kwargs
+    
+    def _get_async_engine_kwargs(self) -> Dict[str, Any]:
+        """Get async engine configuration based on database type"""
+        database_url = settings.get_database_url()
+        
+        base_kwargs = {
+            "echo": settings.debug,
+            "future": True
+        }
+        
+        if database_url.startswith("sqlite"):
+            # SQLite-specific configuration for async
+            base_kwargs.update({
+                "poolclass": NullPool,  # SQLite doesn't need connection pooling
+            })
+        else:
+            # PostgreSQL/MySQL configuration with async connection pooling
+            base_kwargs.update({
+                "poolclass": AsyncAdaptedQueuePool,  # Use AsyncAdaptedQueuePool for async engines
+                "pool_size": settings.database.pool_size,
+                "max_overflow": settings.database.max_overflow,
+                "pool_timeout": settings.database.pool_timeout,
+                "pool_recycle": settings.database.pool_recycle,
+                "pool_pre_ping": True  # Verify connections before use
+            })
+            
+        return base_kwargs
+    
+    def _setup_sql_logging(self, engine):
+        """Setup SQL logging for debugging"""
+        if settings.debug:
+            @event.listens_for(engine, "before_cursor_execute")
+            def log_sql(conn, cursor, statement, parameters, context, executemany):
+                """Log SQL statements in debug mode"""
+                logger.debug(f"SQL: {statement}")
+                if parameters:
+                    logger.debug(f"Parameters: {parameters}")
+    
+    async def initialize(self):
+        """Initialize database connections and create tables"""
+        try:
+            logger.info("🚀 Initializing SAAP Database Connection...")
+            
+            database_url = settings.get_database_url()
+            
+            # Create sync engine for migrations and admin tasks
+            sync_kwargs = self._get_sync_engine_kwargs()
+            self.engine = create_engine(database_url, **sync_kwargs)
+            
+            # Setup SQL logging for sync engine
+            self._setup_sql_logging(self.engine)
+            
+            # Create async engine for main application
+            async_url = database_url.replace("sqlite://", "sqlite+aiosqlite://")
+            if not database_url.startswith("sqlite"):
+                # For PostgreSQL: replace postgresql:// with postgresql+asyncpg://
+                async_url = database_url.replace("postgresql://", "postgresql+asyncpg://")
+            
+            async_kwargs = self._get_async_engine_kwargs()
+            self.async_engine = create_async_engine(async_url, **async_kwargs)
+            
+            # Setup SQL logging for async engine
+            self._setup_sql_logging(self.async_engine.sync_engine)
+            
+            # Create session factories
+            self.SessionLocal = sessionmaker(
+                bind=self.engine,
+                autocommit=False,
+                autoflush=False,
+                expire_on_commit=False
+            )
+            
+            self.AsyncSessionLocal = async_sessionmaker(
+                bind=self.async_engine,
+                class_=AsyncSession,
+                autocommit=False,
+                autoflush=False,
+                expire_on_commit=False
+            )
+            
+            # Create database tables
+            await self._create_tables()
+            
+            # Perform initial health check
+            await self._update_health_status()
+            
+            self.is_initialized = True
+            logger.info(f"✅ Database initialized successfully: {database_url}")
+            
+        except Exception as e:
+            logger.error(f"❌ Database initialization failed: {e}")
+            self.health_status = {"status": "failed", "error": str(e)}
+            raise
+    
+    async def _create_tables(self):
+        """Create database tables if they don't exist"""
+        try:
+            if settings.debug:
+                logger.debug("🔧 Creating database tables...")
+                
+            if settings.get_database_url().startswith("sqlite"):
+                # For SQLite, use sync engine
+                Base.metadata.create_all(bind=self.engine)
+                logger.info("✅ Database tables created (SQLite)")
+            else:
+                # For PostgreSQL/MySQL, use async engine
+                async with self.async_engine.begin() as conn:
+                    await conn.run_sync(Base.metadata.create_all)
+                logger.info("✅ Database tables created (Async)")
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to create database tables: {e}")
+            raise
+    
+    @asynccontextmanager
+    async def get_async_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """Get async database session with automatic cleanup"""
+        if not self.is_initialized:
+            await self.initialize()
+            
+        session = self.AsyncSessionLocal()
+        try:
+            yield session
+            await session.commit()
+        except Exception as e:
+            await session.rollback()
+            logger.error(f"❌ Database session error: {e}")
+            raise
+        finally:
+            await session.close()
+    
+    def get_sync_session(self) -> Session:
+        """Get sync database session (for migrations and admin tasks)"""
+        if not self.engine:
+            raise RuntimeError("Database not initialized")
+        return self.SessionLocal()
+    
+    async def _update_health_status(self):
+        """Update database health monitoring status"""
+        try:
+            start_time = datetime.utcnow()
+            
+            # Test database connectivity
+            async with self.get_async_session() as session:
+                result = await session.execute(text("SELECT 1"))
+                result.fetchone()
+            
+            end_time = datetime.utcnow()
+            response_time = (end_time - start_time).total_seconds() * 1000  # Convert to milliseconds
+            
+            # Get agent count - with proper error handling
+            agent_count = 0
+            active_agent_count = 0
+            
+            try:
+                async with self.get_async_session() as session:
+                    # Check if agents table exists first
+                    check_table_query = text("""
+                        SELECT COUNT(*) FROM information_schema.tables 
+                        WHERE table_name = 'agents'
+                    """)
+                    
+                    # For SQLite, use different query
+                    if settings.get_database_url().startswith("sqlite"):
+                        check_table_query = text("""
+                            SELECT COUNT(*) FROM sqlite_master 
+                            WHERE type='table' AND name='agents'
+                        """)
+                    
+                    table_exists_result = await session.execute(check_table_query)
+                    table_exists = table_exists_result.scalar() > 0
+                    
+                    if table_exists:
+                        agent_count_result = await session.execute(text("SELECT COUNT(*) FROM agents"))
+                        agent_count = agent_count_result.scalar()
+                        
+                        active_agent_count_result = await session.execute(
+                            text("SELECT COUNT(*) FROM agents WHERE status = 'active'")
+                        )
+                        active_agent_count = active_agent_count_result.scalar()
+                        
+            except Exception as table_error:
+                logger.debug(f"Tables not ready yet: {table_error}")
+                # This is expected during initial setup
+            
+            self.health_status = {
+                "status": "healthy",
+                "database_type": settings.get_database_url().split("://")[0],
+                "response_time_ms": response_time,
+                "agent_count": agent_count,
+                "active_agent_count": active_agent_count,
+                "connection_pool": {
+                    "size": getattr(self.async_engine.pool, 'size', 0) if self.async_engine else 0,
+                    "checked_out": getattr(self.async_engine.pool, 'checked_out', 0) if self.async_engine else 0
+                },
+                "timestamp": datetime.utcnow().isoformat()
+            }
+            
+            self.last_health_check = datetime.utcnow()
+            
+            # Save health check to database (optional)
+            await self._save_health_check(response_time, agent_count, active_agent_count)
+            
+        except Exception as e:
+            logger.error(f"❌ Database health check failed: {e}")
+            self.health_status = {
+                "status": "error",
+                "error": str(e),
+                "timestamp": datetime.utcnow().isoformat()
+            }
+    
+    async def _save_health_check(self, response_time: float, agent_count: int, active_agent_count: int):
+        """Save health check result to database"""
+        try:
+            async with self.get_async_session() as session:
+                health_check = DBHealthCheck(
+                    component="database",
+                    status=self.health_status["status"],
+                    response_time_ms=response_time,
+                    agent_count=agent_count,
+                    active_agent_count=active_agent_count,
+                    details={"database_type": settings.get_database_url().split("://")[0]}
+                )
+                session.add(health_check)
+                await session.commit()
+                
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to save health check: {e}")
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Get current database health status"""
+        # Update health status if it's been more than 30 seconds
+        if not self.last_health_check or (datetime.utcnow() - self.last_health_check).seconds > 30:
+            await self._update_health_status()
+        
+        return self.health_status
+    
+    async def get_performance_metrics(self) -> Dict[str, Any]:
+        """Get database performance metrics"""
+        try:
+            async with self.get_async_session() as session:
+                # Get recent health checks
+                recent_checks_query = text("""
+                    SELECT * FROM health_checks 
+                    WHERE component = 'database' 
+                    ORDER BY created_at DESC 
+                    LIMIT 10
+                """)
+                
+                recent_checks = await session.execute(recent_checks_query)
+                checks = recent_checks.fetchall()
+                
+                if checks:
+                    avg_response_time = sum(check.response_time_ms for check in checks) / len(checks)
+                    latest_check = checks[0]
+                    
+                    return {
+                        "average_response_time_ms": avg_response_time,
+                        "latest_agent_count": latest_check.agent_count,
+                        "latest_active_agents": latest_check.active_agent_count,
+                        "health_checks_count": len(checks),
+                        "timestamp": datetime.utcnow().isoformat()
+                    }
+                else:
+                    return {"message": "No performance data available"}
+                    
+        except Exception as e:
+            logger.error(f"❌ Failed to get performance metrics: {e}")
+            return {"error": str(e)}
+    
+    async def cleanup_old_data(self, days: int = 30):
+        """Clean up old data from database"""
+        try:
+            cutoff_date = datetime.utcnow() - timedelta(days=days)
+            
+            async with self.get_async_session() as session:
+                # Clean old chat messages
+                await session.execute(
+                    text("DELETE FROM chat_messages WHERE created_at < :cutoff_date"),
+                    {"cutoff_date": cutoff_date}
+                )
+                
+                # Clean old health checks
+                await session.execute(
+                    text("DELETE FROM health_checks WHERE created_at < :cutoff_date"),
+                    {"cutoff_date": cutoff_date}
+                )
+                
+                # Clean old system logs
+                await session.execute(
+                    text("DELETE FROM system_logs WHERE created_at < :cutoff_date"),
+                    {"cutoff_date": cutoff_date}
+                )
+                
+                await session.commit()
+                
+            logger.info(f"✅ Cleaned up data older than {days} days")
+            
+        except Exception as e:
+            logger.error(f"❌ Data cleanup failed: {e}")
+    
+    async def close(self):
+        """Close database connections"""
+        try:
+            logger.info("🔧 Closing database connections...")
+            
+            if self.async_engine:
+                await self.async_engine.dispose()
+            
+            if self.engine:
+                self.engine.dispose()
+            
+            self.is_initialized = False
+            logger.info("✅ Database connections closed")
+            
+        except Exception as e:
+            logger.error(f"❌ Error closing database: {e}")
+
+# Global database manager instance
+db_manager = DatabaseManager()
+
+# Convenience functions for dependency injection
+async def get_db_session() -> AsyncGenerator[AsyncSession, None]:
+    """FastAPI dependency for getting database session"""
+    async with db_manager.get_async_session() as session:
+        yield session
+
+def get_sync_db_session() -> Session:
+    """Get synchronous database session"""
+    return db_manager.get_sync_session()
+
+if __name__ == "__main__":
+    async def test_database():
+        """Test database connectivity"""
+        await db_manager.initialize()
+        
+        health = await db_manager.health_check()
+        print(f"🔍 Database Health: {health}")
+        
+        metrics = await db_manager.get_performance_metrics()
+        print(f"📊 Performance Metrics: {metrics}")
+        
+        await db_manager.close()
+    
+    asyncio.run(test_database())

backend/cost_efficiency_logger.py

@@ -0,0 +1,478 @@
+"""
+SAAP Cost Efficiency Logger - Advanced Cost Tracking & Analytics
+Monitors OpenRouter costs, performance metrics, and budget management
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass, asdict
+from pathlib import Path
+import sqlite3
+import aiosqlite
+from collections import defaultdict
+
+from ..config.settings import get_settings
+
+# Initialize cost logging
+cost_logger = logging.getLogger("saap.cost")
+performance_logger = logging.getLogger("saap.performance")
+
+@dataclass
+class CostAnalytics:
+    """Comprehensive cost analytics"""
+    time_period: str
+    total_cost_usd: float
+    total_requests: int
+    successful_requests: int
+    failed_requests: int
+    average_cost_per_request: float
+    total_tokens: int
+    average_response_time: float
+    cost_per_1k_tokens: float
+    tokens_per_second: float
+    top_expensive_models: List[Dict[str, Any]]
+    cost_by_agent: Dict[str, float]
+    cost_by_provider: Dict[str, float]
+    daily_budget_utilization: float
+    cost_trend_24h: List[Dict[str, Any]]
+    efficiency_score: float  # Tokens per dollar
+
+@dataclass
+class PerformanceBenchmark:
+    """Performance benchmarking data"""
+    provider: str
+    model: str
+    avg_response_time: float
+    tokens_per_second: float
+    cost_per_token: float
+    success_rate: float
+    cost_efficiency_score: float
+    sample_size: int
+
+class CostEfficiencyLogger:
+    """Advanced cost tracking and analytics system"""
+    
+    def __init__(self):
+        self.settings = get_settings()
+        self.cost_db_path = "logs/saap_cost_tracking.db"
+        self.analytics_cache = {}
+        self.cost_alerts = []
+        
+        # Ensure logs directory exists
+        Path("logs").mkdir(exist_ok=True)
+        
+        # Initialize database
+        asyncio.create_task(self._initialize_database())
+        
+        cost_logger.info("💰 Cost Efficiency Logger initialized")
+    
+    async def _initialize_database(self):
+        """Initialize SQLite database for cost tracking"""
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS cost_metrics (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TEXT NOT NULL,
+                    agent_id TEXT NOT NULL,
+                    provider TEXT NOT NULL,
+                    model TEXT NOT NULL,
+                    input_tokens INTEGER NOT NULL,
+                    output_tokens INTEGER NOT NULL,
+                    total_tokens INTEGER NOT NULL,
+                    cost_usd REAL NOT NULL,
+                    response_time_seconds REAL NOT NULL,
+                    request_success BOOLEAN NOT NULL,
+                    cost_per_1k_tokens REAL,
+                    tokens_per_second REAL,
+                    metadata TEXT
+                )
+            """)
+            
+            await db.execute("""
+                CREATE INDEX IF NOT EXISTS idx_timestamp ON cost_metrics(timestamp)
+            """)
+            
+            await db.execute("""
+                CREATE INDEX IF NOT EXISTS idx_agent_id ON cost_metrics(agent_id)
+            """)
+            
+            await db.execute("""
+                CREATE INDEX IF NOT EXISTS idx_provider ON cost_metrics(provider)
+            """)
+            
+            await db.commit()
+    
+    async def log_cost_metrics(self, metrics_data: Dict[str, Any]):
+        """Log cost metrics to database and generate analytics"""
+        
+        # Calculate derived metrics
+        metrics_data['cost_per_1k_tokens'] = (
+            metrics_data['cost_usd'] / (metrics_data['total_tokens'] / 1000) 
+            if metrics_data['total_tokens'] > 0 else 0
+        )
+        
+        metrics_data['tokens_per_second'] = (
+            metrics_data['total_tokens'] / metrics_data['response_time_seconds'] 
+            if metrics_data['response_time_seconds'] > 0 else 0
+        )
+        
+        # Store in database
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            await db.execute("""
+                INSERT INTO cost_metrics (
+                    timestamp, agent_id, provider, model, input_tokens, output_tokens,
+                    total_tokens, cost_usd, response_time_seconds, request_success,
+                    cost_per_1k_tokens, tokens_per_second, metadata
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                metrics_data['timestamp'],
+                metrics_data['agent_id'],
+                metrics_data['provider'],
+                metrics_data['model'],
+                metrics_data['input_tokens'],
+                metrics_data['output_tokens'],
+                metrics_data['total_tokens'],
+                metrics_data['cost_usd'],
+                metrics_data['response_time_seconds'],
+                metrics_data['request_success'],
+                metrics_data['cost_per_1k_tokens'],
+                metrics_data['tokens_per_second'],
+                json.dumps(metrics_data.get('metadata', {}))
+            ))
+            await db.commit()
+        
+        # Real-time cost logging
+        if metrics_data['request_success']:
+            cost_logger.info(
+                f"💰 COST: {metrics_data['agent_id']} | "
+                f"${metrics_data['cost_usd']:.6f} | "
+                f"{metrics_data['total_tokens']} tokens | "
+                f"{metrics_data['response_time_seconds']:.2f}s | "
+                f"{metrics_data['tokens_per_second']:.1f} tok/s | "
+                f"${metrics_data['cost_per_1k_tokens']:.4f}/1k"
+            )
+        else:
+            cost_logger.error(
+                f"❌ FAILED: {metrics_data['agent_id']} | "
+                f"{metrics_data['provider']} | "
+                f"{metrics_data['response_time_seconds']:.2f}s timeout"
+            )
+        
+        # Check for budget alerts
+        await self._check_budget_alerts()
+    
+    async def _check_budget_alerts(self):
+        """Check and generate budget alerts"""
+        daily_cost = await self.get_daily_cost()
+        daily_budget = self.settings.agents.daily_cost_budget
+        usage_percentage = (daily_cost / daily_budget) * 100
+        
+        # Generate alerts at specific thresholds
+        thresholds = [50, 75, 90, 95, 100]
+        
+        for threshold in thresholds:
+            if usage_percentage >= threshold:
+                alert_key = f"daily_budget_{threshold}"
+                if alert_key not in self.cost_alerts:
+                    self.cost_alerts.append(alert_key)
+                    
+                    if threshold < 100:
+                        cost_logger.warning(
+                            f"⚠️ BUDGET ALERT: ${daily_cost:.4f} / ${daily_budget} "
+                            f"({usage_percentage:.1f}%) - {threshold}% threshold reached"
+                        )
+                    else:
+                        cost_logger.critical(
+                            f"🚨 BUDGET EXCEEDED: ${daily_cost:.4f} / ${daily_budget} "
+                            f"({usage_percentage:.1f}%) - Switching to free models!"
+                        )
+                break
+    
+    async def get_daily_cost(self) -> float:
+        """Get current daily cost"""
+        today = datetime.now().strftime('%Y-%m-%d')
+        
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            cursor = await db.execute("""
+                SELECT SUM(cost_usd) FROM cost_metrics 
+                WHERE date(timestamp) = ? AND request_success = 1
+            """, (today,))
+            result = await cursor.fetchone()
+            return result[0] or 0.0
+    
+    async def get_cost_analytics(self, hours: int = 24) -> CostAnalytics:
+        """Generate comprehensive cost analytics"""
+        
+        cutoff_time = (datetime.now() - timedelta(hours=hours)).isoformat()
+        
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            # Basic metrics
+            cursor = await db.execute("""
+                SELECT 
+                    COUNT(*) as total_requests,
+                    SUM(CASE WHEN request_success = 1 THEN 1 ELSE 0 END) as successful_requests,
+                    SUM(CASE WHEN request_success = 0 THEN 1 ELSE 0 END) as failed_requests,
+                    SUM(cost_usd) as total_cost,
+                    SUM(total_tokens) as total_tokens,
+                    AVG(response_time_seconds) as avg_response_time
+                FROM cost_metrics 
+                WHERE timestamp >= ?
+            """, (cutoff_time,))
+            
+            basic_stats = await cursor.fetchone()
+            
+            if not basic_stats or basic_stats[0] == 0:
+                return self._empty_analytics(hours)
+            
+            total_requests, successful_requests, failed_requests, total_cost, total_tokens, avg_response_time = basic_stats
+            
+            # Cost by agent
+            cursor = await db.execute("""
+                SELECT agent_id, SUM(cost_usd) as cost 
+                FROM cost_metrics 
+                WHERE timestamp >= ? AND request_success = 1
+                GROUP BY agent_id 
+                ORDER BY cost DESC
+            """, (cutoff_time,))
+            
+            cost_by_agent = {row[0]: row[1] for row in await cursor.fetchall()}
+            
+            # Cost by provider
+            cursor = await db.execute("""
+                SELECT provider, SUM(cost_usd) as cost 
+                FROM cost_metrics 
+                WHERE timestamp >= ? AND request_success = 1
+                GROUP BY provider 
+                ORDER BY cost DESC
+            """, (cutoff_time,))
+            
+            cost_by_provider = {row[0]: row[1] for row in await cursor.fetchall()}
+            
+            # Top expensive models
+            cursor = await db.execute("""
+                SELECT model, SUM(cost_usd) as total_cost, COUNT(*) as requests,
+                       AVG(cost_per_1k_tokens) as avg_cost_per_1k
+                FROM cost_metrics 
+                WHERE timestamp >= ? AND request_success = 1
+                GROUP BY model 
+                ORDER BY total_cost DESC 
+                LIMIT 5
+            """, (cutoff_time,))
+            
+            top_expensive_models = [
+                {
+                    'model': row[0], 
+                    'total_cost': row[1], 
+                    'requests': row[2], 
+                    'avg_cost_per_1k_tokens': row[3]
+                } 
+                for row in await cursor.fetchall()
+            ]
+            
+            # Hourly cost trend (last 24 hours)
+            cursor = await db.execute("""
+                SELECT 
+                    strftime('%Y-%m-%d %H:00', timestamp) as hour,
+                    SUM(cost_usd) as cost,
+                    COUNT(*) as requests
+                FROM cost_metrics 
+                WHERE timestamp >= datetime('now', '-24 hours') AND request_success = 1
+                GROUP BY strftime('%Y-%m-%d %H:00', timestamp)
+                ORDER BY hour
+            """, ())
+            
+            cost_trend_24h = [
+                {'hour': row[0], 'cost': row[1], 'requests': row[2]} 
+                for row in await cursor.fetchall()
+            ]
+            
+            # Calculate derived metrics
+            average_cost_per_request = total_cost / total_requests if total_requests > 0 else 0
+            cost_per_1k_tokens = (total_cost / (total_tokens / 1000)) if total_tokens > 0 else 0
+            tokens_per_second = total_tokens / (avg_response_time * total_requests) if avg_response_time and total_requests > 0 else 0
+            efficiency_score = total_tokens / total_cost if total_cost > 0 else 0
+            
+            # Daily budget utilization
+            daily_cost = await self.get_daily_cost()
+            daily_budget_utilization = (daily_cost / self.settings.agents.daily_cost_budget) * 100
+            
+            return CostAnalytics(
+                time_period=f"{hours}h",
+                total_cost_usd=total_cost or 0,
+                total_requests=total_requests or 0,
+                successful_requests=successful_requests or 0,
+                failed_requests=failed_requests or 0,
+                average_cost_per_request=average_cost_per_request,
+                total_tokens=total_tokens or 0,
+                average_response_time=avg_response_time or 0,
+                cost_per_1k_tokens=cost_per_1k_tokens,
+                tokens_per_second=tokens_per_second,
+                top_expensive_models=top_expensive_models,
+                cost_by_agent=cost_by_agent,
+                cost_by_provider=cost_by_provider,
+                daily_budget_utilization=daily_budget_utilization,
+                cost_trend_24h=cost_trend_24h,
+                efficiency_score=efficiency_score
+            )
+    
+    def _empty_analytics(self, hours: int) -> CostAnalytics:
+        """Return empty analytics object"""
+        return CostAnalytics(
+            time_period=f"{hours}h",
+            total_cost_usd=0.0,
+            total_requests=0,
+            successful_requests=0,
+            failed_requests=0,
+            average_cost_per_request=0.0,
+            total_tokens=0,
+            average_response_time=0.0,
+            cost_per_1k_tokens=0.0,
+            tokens_per_second=0.0,
+            top_expensive_models=[],
+            cost_by_agent={},
+            cost_by_provider={},
+            daily_budget_utilization=0.0,
+            cost_trend_24h=[],
+            efficiency_score=0.0
+        )
+    
+    async def get_performance_benchmarks(self, hours: int = 24) -> List[PerformanceBenchmark]:
+        """Get performance benchmarks by provider and model"""
+        
+        cutoff_time = (datetime.now() - timedelta(hours=hours)).isoformat()
+        
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            cursor = await db.execute("""
+                SELECT 
+                    provider,
+                    model,
+                    AVG(response_time_seconds) as avg_response_time,
+                    AVG(tokens_per_second) as avg_tokens_per_second,
+                    AVG(cost_per_1k_tokens) as avg_cost_per_1k,
+                    SUM(CASE WHEN request_success = 1 THEN 1 ELSE 0 END) * 100.0 / COUNT(*) as success_rate,
+                    COUNT(*) as sample_size,
+                    SUM(total_tokens) as total_tokens,
+                    SUM(cost_usd) as total_cost
+                FROM cost_metrics 
+                WHERE timestamp >= ?
+                GROUP BY provider, model
+                HAVING COUNT(*) >= 3
+                ORDER BY avg_tokens_per_second DESC
+            """, (cutoff_time,))
+            
+            benchmarks = []
+            
+            for row in await cursor.fetchall():
+                provider, model, avg_response_time, avg_tokens_per_second, avg_cost_per_1k, success_rate, sample_size, total_tokens, total_cost = row
+                
+                # Calculate cost efficiency score (tokens per dollar)
+                cost_efficiency_score = total_tokens / total_cost if total_cost > 0 else 0
+                cost_per_token = total_cost / total_tokens if total_tokens > 0 else 0
+                
+                benchmarks.append(PerformanceBenchmark(
+                    provider=provider,
+                    model=model,
+                    avg_response_time=avg_response_time,
+                    tokens_per_second=avg_tokens_per_second or 0,
+                    cost_per_token=cost_per_token,
+                    success_rate=success_rate / 100,  # Convert to decimal
+                    cost_efficiency_score=cost_efficiency_score,
+                    sample_size=sample_size
+                ))
+            
+            return benchmarks
+    
+    async def generate_cost_report(self, hours: int = 24) -> str:
+        """Generate detailed cost report"""
+        analytics = await self.get_cost_analytics(hours)
+        benchmarks = await self.get_performance_benchmarks(hours)
+        
+        report_lines = [
+            "=" * 60,
+            f"📊 SAAP Cost Efficiency Report - Last {hours} Hours",
+            "=" * 60,
+            "",
+            "💰 COST SUMMARY:",
+            f"  Total Cost: ${analytics.total_cost_usd:.6f}",
+            f"  Requests: {analytics.total_requests} ({analytics.successful_requests} successful)",
+            f"  Average Cost/Request: ${analytics.average_cost_per_request:.6f}",
+            f"  Daily Budget Used: {analytics.daily_budget_utilization:.1f}%",
+            "",
+            "🔢 TOKEN METRICS:",
+            f"  Total Tokens: {analytics.total_tokens:,}",
+            f"  Cost per 1K Tokens: ${analytics.cost_per_1k_tokens:.4f}",
+            f"  Tokens per Second: {analytics.tokens_per_second:.1f}",
+            f"  Efficiency Score: {analytics.efficiency_score:.1f} tokens/$",
+            ""
+        ]
+        
+        if analytics.cost_by_provider:
+            report_lines.extend([
+                "🏢 COST BY PROVIDER:",
+                *[f"  {provider}: ${cost:.6f}" for provider, cost in analytics.cost_by_provider.items()],
+                ""
+            ])
+        
+        if analytics.cost_by_agent:
+            report_lines.extend([
+                "🤖 COST BY AGENT:",
+                *[f"  {agent}: ${cost:.6f}" for agent, cost in list(analytics.cost_by_agent.items())[:5]],
+                ""
+            ])
+        
+        if analytics.top_expensive_models:
+            report_lines.extend([
+                "💸 TOP EXPENSIVE MODELS:",
+                *[f"  {model['model']}: ${model['total_cost']:.6f} ({model['requests']} requests)" 
+                  for model in analytics.top_expensive_models[:3]],
+                ""
+            ])
+        
+        if benchmarks:
+            report_lines.extend([
+                "⚡ PERFORMANCE BENCHMARKS:",
+                f"{'Provider':<15} {'Model':<25} {'Speed (t/s)':<12} {'Cost/Token':<12} {'Success':<8}",
+                "-" * 80
+            ])
+            
+            for bench in benchmarks[:5]:
+                report_lines.append(
+                    f"{bench.provider:<15} {bench.model[:24]:<25} {bench.tokens_per_second:<12.1f} "
+                    f"${bench.cost_per_token:<11.8f} {bench.success_rate:<8.1%}"
+                )
+            
+            report_lines.append("")
+        
+        report_lines.extend([
+            "=" * 60,
+            f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            "=" * 60
+        ])
+        
+        return "\n".join(report_lines)
+    
+    async def cleanup_old_data(self, days_to_keep: int = 30):
+        """Cleanup old cost tracking data"""
+        cutoff_date = (datetime.now() - timedelta(days=days_to_keep)).isoformat()
+        
+        async with aiosqlite.connect(self.cost_db_path) as db:
+            cursor = await db.execute("""
+                DELETE FROM cost_metrics WHERE timestamp < ?
+            """, (cutoff_date,))
+            
+            deleted_rows = cursor.rowcount
+            await db.commit()
+            
+            if deleted_rows > 0:
+                cost_logger.info(f"🧹 Cleaned up {deleted_rows} old cost records (>{days_to_keep} days)")
+    
+    def reset_daily_alerts(self):
+        """Reset daily cost alerts (called at midnight)"""
+        self.cost_alerts.clear()
+        cost_logger.info("🔔 Daily cost alerts reset")
+
+# Global cost logger instance
+cost_efficiency_logger = CostEfficiencyLogger()

backend/database/connection.py

@@ -114,13 +114,8 @@ class DatabaseManager:
             database_url = settings.get_database_url()
             
             # Create sync engine for migrations and admin tasks
-            # Fix: Use psycopg3 driver explicitly for PostgreSQL sync connections
-            sync_url = database_url
-            if database_url.startswith("postgresql://"):
-                sync_url = database_url.replace("postgresql://", "postgresql+psycopg://")
-            
             sync_kwargs = self._get_sync_engine_kwargs()
-            self.engine = create_engine(sync_url, **sync_kwargs)
+            self.engine = create_engine(database_url, **sync_kwargs)
             
             # Setup SQL logging for sync engine
             self._setup_sql_logging(self.engine)

backend/database/models.py

@@ -311,98 +311,6 @@ class DBSystemLog(Base):
         Index('idx_log_logger_created', 'logger_name', 'created_at'),
     )
 
-class DBLLMCost(Base):
-    """
-    Database model for LLM cost tracking
-    Stores all LLM API costs for evaluation and analysis
-    """
-    __tablename__ = "llm_costs"
-    
-    # Primary Key (🔧 FIXED: Match actual DB column name 'id')
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    
-    # Foreign Key to Agent
-    agent_id = Column(String(100), ForeignKey("agents.id"), nullable=False, index=True)
-    
-    # LLM Details
-    model_name = Column(String(200), nullable=False, index=True)
-    provider = Column(String(100), nullable=False, index=True)  # colossus, openrouter
-    
-    # Token Usage
-    input_tokens = Column(Integer, nullable=False, default=0)
-    output_tokens = Column(Integer, nullable=False, default=0)
-    
-    # Cost
-    cost_usd = Column(Float, nullable=False, default=0.0)
-    
-    # Performance Metrics (🔧 FIXED: Match actual DB column names)
-    response_time = Column(Float, nullable=True)  # DB has 'response_time', not 'response_time_seconds'
-    success = Column(Boolean, default=True)  # DB has 'success', not 'request_success'
-    error_message = Column(Text, nullable=True)  # DB has 'error_message' instead of 'privacy_level'
-    
-    # Timestamp
-    created_at = Column(TIMESTAMP(timezone=True), default=func.now(), nullable=False, index=True)
-    
-    # Indexes for cost analytics
-    __table_args__ = (
-        Index('idx_cost_agent_created', 'agent_id', 'created_at'),
-        Index('idx_cost_provider_created', 'provider', 'created_at'),
-        Index('idx_cost_model_created', 'model_name', 'created_at'),
-        Index('idx_cost_date', 'created_at'),
-    )
-
-
-class DBMultiAgentMessage(Base):
-    """
-    Database model for Multi-Agent Chat message history
-    Stores all multi-agent conversations for persistence across sessions
-    """
-    __tablename__ = "multi_agent_messages"
-    
-    # Primary Key
-    id = Column(Integer, primary_key=True, index=True, autoincrement=True)
-    
-    # Session identifier (to group messages by session)
-    session_id = Column(String(100), nullable=False, index=True, default="default")
-    
-    # Message Content
-    content = Column(Text, nullable=False)
-    agent_id = Column(String(100), nullable=False, index=True)
-    agent_name = Column(String(200), nullable=False)
-    message_type = Column(String(50), nullable=False, default="agent")  # user, coordinator, specialist, delegation, error
-    
-    # Additional metadata
-    role = Column(String(100), nullable=True)  # Master Coordinator, Specialist, etc.
-    provider = Column(String(50), nullable=True)  # colossus, openrouter
-    processing_time = Column(Float, nullable=True)
-    cost_usd = Column(Float, nullable=True)
-    
-    # Timestamp
-    created_at = Column(TIMESTAMP(timezone=True), default=func.now(), nullable=False, index=True)
-    
-    # Indexes for performance
-    __table_args__ = (
-        Index('idx_multi_agent_session_created', 'session_id', 'created_at'),
-        Index('idx_multi_agent_agent_created', 'agent_id', 'created_at'),
-    )
-    
-    def to_dict(self):
-        """Convert to dictionary for API response"""
-        return {
-            "id": self.id,
-            "session_id": self.session_id,
-            "content": self.content,
-            "agent": self.agent_id,
-            "agentName": self.agent_name,
-            "type": self.message_type,
-            "role": self.role,
-            "provider": self.provider,
-            "processingTime": self.processing_time,
-            "cost": f"${self.cost_usd:.6f}" if self.cost_usd else None,
-            "timestamp": self.created_at.isoformat() if self.created_at else None
-        }
-
-
 class DBHealthCheck(Base):
     """
     Database model for system health monitoring

backend/database_service.py

@@ -0,0 +1,382 @@
+"""
+SAAP Database Service - Production Ready
+High-level database operations for agent management and chat persistence
+"""
+
+import logging
+from typing import List, Optional, Dict, Any
+from datetime import datetime, timedelta
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import text, select, update, delete, and_, desc
+from sqlalchemy.exc import SQLAlchemyError
+
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession, DBSystemLog, DBHealthCheck
+from models.agent import SaapAgent
+
+logger = logging.getLogger(__name__)
+
+class DatabaseService:
+    """
+    Database service layer for SAAP production deployment
+    Provides high-level database operations with error handling and logging
+    """
+    
+    def __init__(self):
+        self.is_initialized = False
+        self.db_manager = db_manager
+        
+    async def initialize(self):
+        """Initialize database service"""
+        if not self.db_manager.is_initialized:
+            await self.db_manager.initialize()
+        self.is_initialized = True
+        logger.info("✅ Database Service initialized")
+    
+    # =====================================================
+    # AGENT MANAGEMENT OPERATIONS
+    # =====================================================
+    
+    async def save_agent(self, agent: SaapAgent) -> bool:
+        """Save or update agent in database"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                # Check if agent exists
+                existing_agent = await session.get(DBAgent, agent.id)
+                
+                if existing_agent:
+                    # Update existing agent
+                    existing_agent.name = agent.name
+                    existing_agent.agent_type = agent.type.value
+                    existing_agent.color = agent.color
+                    existing_agent.avatar = agent.avatar
+                    existing_agent.description = agent.description
+                    existing_agent.llm_config = agent.llm_config.model_dump()
+                    existing_agent.capabilities = agent.capabilities
+                    existing_agent.personality = agent.personality.model_dump() if agent.personality else None
+                    existing_agent.status = agent.status.value
+                    existing_agent.last_active = agent.metrics.last_active if agent.metrics else None
+                    existing_agent.metrics = agent.metrics.model_dump() if agent.metrics else None
+                    existing_agent.updated_at = datetime.utcnow()
+                    existing_agent.tags = agent.tags
+                    
+                    logger.info(f"📝 Updated agent in database: {agent.name}")
+                else:
+                    # Create new agent
+                    db_agent = DBAgent.from_saap_agent(agent)
+                    session.add(db_agent)
+                    logger.info(f"💾 Saved new agent to database: {agent.name}")
+                
+                await session.commit()
+                return True
+                
+        except SQLAlchemyError as e:
+            logger.error(f"❌ Database error saving agent {agent.id}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"❌ Unexpected error saving agent {agent.id}: {e}")
+            return False
+    
+    async def load_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Load single agent from database"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                db_agent = await session.get(DBAgent, agent_id)
+                
+                if db_agent:
+                    return db_agent.to_saap_agent()
+                else:
+                    logger.warning(f"⚠️ Agent not found in database: {agent_id}")
+                    return None
+                    
+        except Exception as e:
+            logger.error(f"❌ Error loading agent {agent_id}: {e}")
+            return None
+    
+    async def load_all_agents(self) -> List[SaapAgent]:
+        """Load all agents from database"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                result = await session.execute(
+                    select(DBAgent).order_by(DBAgent.created_at)
+                )
+                db_agents = result.scalars().all()
+                
+                saap_agents = []
+                for db_agent in db_agents:
+                    try:
+                        saap_agent = db_agent.to_saap_agent()
+                        saap_agents.append(saap_agent)
+                    except Exception as e:
+                        logger.error(f"❌ Error converting DB agent {db_agent.id}: {e}")
+                
+                logger.info(f"📋 Loaded {len(saap_agents)} agents from database")
+                return saap_agents
+                
+        except Exception as e:
+            logger.error(f"❌ Error loading agents: {e}")
+            return []
+    
+    async def delete_agent(self, agent_id: str) -> bool:
+        """Delete agent and all related data"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                # Delete agent (cascading will delete related chat_messages and sessions)
+                result = await session.execute(
+                    delete(DBAgent).where(DBAgent.id == agent_id)
+                )
+                
+                if result.rowcount > 0:
+                    await session.commit()
+                    logger.info(f"🗑️ Deleted agent from database: {agent_id}")
+                    return True
+                else:
+                    logger.warning(f"⚠️ Agent not found for deletion: {agent_id}")
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"❌ Error deleting agent {agent_id}: {e}")
+            return False
+    
+    async def get_agent_statistics(self) -> Dict[str, Any]:
+        """Get comprehensive agent statistics"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                # Total agents by status
+                status_result = await session.execute(text(
+                    "SELECT status, COUNT(*) as count FROM agents GROUP BY status"
+                ))
+                status_breakdown = {row.status: row.count for row in status_result}
+                
+                # Total agents
+                total_result = await session.execute(text("SELECT COUNT(*) FROM agents"))
+                total_agents = total_result.scalar()
+                
+                # Active agents
+                active_result = await session.execute(text(
+                    "SELECT COUNT(*) FROM agents WHERE status = 'active'"
+                ))
+                active_agents = active_result.scalar()
+                
+                # Agent types
+                type_result = await session.execute(text(
+                    "SELECT agent_type, COUNT(*) as count FROM agents GROUP BY agent_type"
+                ))
+                type_breakdown = {row.agent_type: row.count for row in type_result}
+                
+                # Recent activity
+                recent_result = await session.execute(text(
+                    "SELECT COUNT(*) FROM agents WHERE last_active > :cutoff"
+                ), {"cutoff": datetime.utcnow() - timedelta(hours=24)})
+                recent_active = recent_result.scalar()
+                
+                return {
+                    "total_agents": total_agents,
+                    "active_agents": active_agents,
+                    "recent_active_24h": recent_active,
+                    "status_breakdown": status_breakdown,
+                    "type_breakdown": type_breakdown,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ Error getting agent statistics: {e}")
+            return {"error": str(e)}
+    
+    # =====================================================
+    # CHAT MESSAGE OPERATIONS
+    # =====================================================
+    
+    async def save_chat_message(self, agent_id: str, user_message: str, 
+                              agent_response: str, response_time: float,
+                              metadata: Optional[Dict] = None) -> bool:
+        """Save chat message to database"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                chat_message = DBChatMessage(
+                    agent_id=agent_id,
+                    user_message=user_message,
+                    agent_response=agent_response,
+                    response_time=response_time,
+                    metadata=metadata or {}
+                )
+                
+                session.add(chat_message)
+                await session.commit()
+                
+                logger.debug(f"💬 Saved chat message for agent {agent_id}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"❌ Error saving chat message: {e}")
+            return False
+    
+    async def get_chat_history(self, agent_id: str, limit: int = 100) -> List[Dict]:
+        """Get chat history for an agent"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                result = await session.execute(
+                    select(DBChatMessage)
+                    .where(DBChatMessage.agent_id == agent_id)
+                    .order_by(desc(DBChatMessage.created_at))
+                    .limit(limit)
+                )
+                
+                messages = result.scalars().all()
+                
+                return [{
+                    "id": msg.id,
+                    "user_message": msg.user_message,
+                    "agent_response": msg.agent_response,
+                    "response_time": msg.response_time,
+                    "created_at": msg.created_at.isoformat(),
+                    "metadata": msg.metadata
+                } for msg in messages]
+                
+        except Exception as e:
+            logger.error(f"❌ Error getting chat history: {e}")
+            return []
+    
+    async def get_chat_statistics(self, agent_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get chat statistics"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                base_query = select(DBChatMessage)
+                if agent_id:
+                    base_query = base_query.where(DBChatMessage.agent_id == agent_id)
+                
+                # Total messages
+                count_result = await session.execute(
+                    select([text("COUNT(*)")]).select_from(base_query.alias())
+                )
+                total_messages = count_result.scalar()
+                
+                # Average response time
+                avg_result = await session.execute(
+                    select([text("AVG(response_time)")]).select_from(base_query.alias())
+                )
+                avg_response_time = avg_result.scalar() or 0.0
+                
+                # Recent activity (24h)
+                recent_query = base_query.where(
+                    DBChatMessage.created_at > datetime.utcnow() - timedelta(hours=24)
+                )
+                recent_result = await session.execute(
+                    select([text("COUNT(*)")]).select_from(recent_query.alias())
+                )
+                recent_messages = recent_result.scalar()
+                
+                return {
+                    "total_messages": total_messages,
+                    "average_response_time": float(avg_response_time),
+                    "recent_messages_24h": recent_messages,
+                    "agent_id": agent_id,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+                
+        except Exception as e:
+            logger.error(f"❌ Error getting chat statistics: {e}")
+            return {"error": str(e)}
+    
+    # =====================================================
+    # AGENT SESSION MANAGEMENT
+    # =====================================================
+    
+    async def start_agent_session(self, agent_id: str, metadata: Optional[Dict] = None) -> int:
+        """Start new agent session"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                agent_session = DBAgentSession(
+                    agent_id=agent_id,
+                    status="active",
+                    metadata=metadata or {}
+                )
+                
+                session.add(agent_session)
+                await session.commit()
+                await session.refresh(agent_session)
+                
+                logger.info(f"🚀 Started session {agent_session.id} for agent {agent_id}")
+                return agent_session.id
+                
+        except Exception as e:
+            logger.error(f"❌ Error starting agent session: {e}")
+            return 0
+    
+    async def end_agent_session(self, session_id: int, end_reason: str = "graceful") -> bool:
+        """End agent session"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                agent_session = await session.get(DBAgentSession, session_id)
+                
+                if agent_session:
+                    agent_session.session_end = datetime.utcnow()
+                    agent_session.status = "completed"
+                    agent_session.end_reason = end_reason
+                    agent_session.calculate_duration()
+                    
+                    await session.commit()
+                    logger.info(f"🔚 Ended session {session_id} ({end_reason})")
+                    return True
+                else:
+                    logger.warning(f"⚠️ Agent session not found: {session_id}")
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"❌ Error ending agent session: {e}")
+            return False
+    
+    # =====================================================
+    # SYSTEM MONITORING
+    # =====================================================
+    
+    async def log_system_event(self, level: str, logger_name: str, message: str,
+                             agent_id: Optional[str] = None, extra_data: Optional[Dict] = None):
+        """Log system event to database"""
+        try:
+            async with self.db_manager.get_async_session() as session:
+                system_log = DBSystemLog(
+                    level=level,
+                    logger_name=logger_name,
+                    message=message,
+                    agent_id=agent_id,
+                    extra_data=extra_data or {}
+                )
+                
+                session.add(system_log)
+                await session.commit()
+                
+        except Exception as e:
+            logger.error(f"❌ Error logging system event: {e}")
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Database health check"""
+        return await self.db_manager.health_check()
+    
+    async def cleanup_old_data(self, days: int = 30):
+        """Clean up old data"""
+        await self.db_manager.cleanup_old_data(days)
+
+# Global database service instance
+db_service = DatabaseService()
+
+if __name__ == "__main__":
+    import asyncio
+    
+    async def test_db_service():
+        """Test database service operations"""
+        await db_service.initialize()
+        
+        # Test health check
+        health = await db_service.health_check()
+        print(f"🔍 Database Health: {health}")
+        
+        # Test agent statistics
+        stats = await db_service.get_agent_statistics()
+        print(f"📊 Agent Stats: {stats}")
+        
+        # Test chat statistics
+        chat_stats = await db_service.get_chat_statistics()
+        print(f"💬 Chat Stats: {chat_stats}")
+    
+    asyncio.run(test_db_service())

backend/main.py

@@ -21,6 +21,7 @@ from dotenv import load_dotenv
 from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
 from contextlib import asynccontextmanager
 from typing import List, Dict, Optional
 import asyncio
@@ -42,54 +43,6 @@ load_dotenv()
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-
-# 💰 COST TRACKING HELPER - Save to PostgreSQL
-async def _save_llm_cost(
-    agent_id: str,
-    provider: str,
-    processing_time: float,
-    success: bool = True,
-    error_message: str = None,
-    input_tokens: int = 100,
-    output_tokens: int = 150,
-    model_name: str = "gpt-4o-mini",
-    cost_usd: float = None
-):
-    """
-    💰 Save LLM cost record to PostgreSQL llm_costs table
-    """
-    try:
-        from database.connection import db_manager
-        from database.models import DBLLMCost
-        
-        # Calculate cost if not provided
-        if cost_usd is None:
-            if provider == "openrouter":
-                cost_usd = (input_tokens / 1000 * 0.00015) + (output_tokens / 1000 * 0.0006)
-            else:
-                cost_usd = 0.0
-        
-        async with db_manager.get_async_session() as session:
-            cost_record = DBLLMCost(
-                agent_id=agent_id,
-                model_name=model_name,
-                provider=provider,
-                input_tokens=input_tokens,
-                output_tokens=output_tokens,
-                cost_usd=cost_usd,
-                response_time=processing_time,
-                success=success,
-                error_message=error_message
-            )
-            session.add(cost_record)
-            await session.commit()
-            logger.info(f"💰 Cost saved to DB: {agent_id} via {provider} - ${cost_usd:.6f}")
-            return True
-    except Exception as e:
-        logger.error(f"❌ Failed to save cost to DB: {e}")
-        return False
-
-
 # 🚀 FIXED: Try Hybrid imports with proper error handling
 HYBRID_MODE = False
 OPENROUTER_ENDPOINTS = False
@@ -260,36 +213,6 @@ if OPENROUTER_ENDPOINTS and hybrid_router and HYBRID_MODE:
 else:
     logger.info("⚠️ OpenRouter endpoints not available")
 
-# 📄 Include Document Upload endpoints
-try:
-    from api.document_upload import router as document_router
-    app.include_router(document_router)
-    logger.info("✅ Document Upload endpoints registered")
-except ImportError as e:
-    logger.warning(f"⚠️ Document Upload endpoints import failed: {e}")
-except Exception as e:
-    logger.warning(f"⚠️ Document Upload endpoints registration failed: {e}")
-
-# 💰 Include Cost Tracking endpoints (PostgreSQL)
-try:
-    from api.cost_tracking import router as cost_router
-    app.include_router(cost_router)
-    logger.info("✅ Cost Tracking endpoints registered (PostgreSQL)")
-except ImportError as e:
-    logger.warning(f"⚠️ Cost Tracking endpoints import failed: {e}")
-except Exception as e:
-    logger.warning(f"⚠️ Cost Tracking endpoints registration failed: {e}")
-
-# 📊 Include System Metrics endpoints (Real-time Monitoring)
-try:
-    from api.system_metrics import router as metrics_router
-    app.include_router(metrics_router)
-    logger.info("✅ System Metrics endpoints registered (Real-time Monitoring)")
-except ImportError as e:
-    logger.warning(f"⚠️ System Metrics endpoints import failed: {e}")
-except Exception as e:
-    logger.warning(f"⚠️ System Metrics endpoints registration failed: {e}")
-
 # Dependency injection
 def get_agent_manager() -> AgentManagerService:
     """Get agent manager instance"""
@@ -301,6 +224,20 @@ def get_websocket_manager() -> WebSocketManager:
     """Get WebSocket manager instance"""
     return saap_app.websocket_manager
 
+# =====================================================
+# STATIC FILES - Serve Vue.js Frontend
+# =====================================================
+
+# Mount static files for frontend (must be AFTER all API routes)
+# This serves the built Vue.js app
+import os
+frontend_dist = "/app/frontend/dist"
+if os.path.exists(frontend_dist):
+    app.mount("/", StaticFiles(directory=frontend_dist, html=True), name="static")
+    logger.info(f"✅ Static files mounted: {frontend_dist}")
+else:
+    logger.warning(f"⚠️ Frontend dist directory not found: {frontend_dist}")
+
 # =====================================================
 # ENHANCED ROOT ENDPOINT WITH HYBRID INFO (API)
 # =====================================================
@@ -1104,17 +1041,6 @@ Respond with ONLY the agent name:
                     "timestamp": datetime.utcnow().isoformat()
                 }
             
-            # 💰 Save cost for Jane direct response
-            await _save_llm_cost(
-                agent_id="jane_alesi",
-                provider=jane_direct_response.get("provider", "openrouter"),
-                processing_time=jane_direct_response.get("response_time", 0),
-                success=True,
-                cost_usd=jane_direct_response.get("cost_usd", 0),
-                input_tokens=len(user_message.split()) * 2,
-                output_tokens=len(jane_direct_response.get("content", "").split()) * 2
-            )
-            
             return {
                 "success": True,
                 "coordinator": "jane_alesi",
@@ -1234,17 +1160,6 @@ Provide a coordinated final response that ensures quality and completeness."""
         
         logger.info(f"✅ Multi-Agent Chat successful: {'Delegated to ' + final_response.get('specialist_agent', '') if final_response.get('delegation_used') else 'Direct response from Jane'}")
         
-        # 💰 Save cost to database
-        await _save_llm_cost(
-            agent_id=final_response.get("specialist_agent", "jane_alesi"),
-            provider=final_response["response"].get("provider", "openrouter"),
-            processing_time=final_response["response"].get("response_time", 0),
-            success=True,
-            cost_usd=final_response["response"].get("cost_usd", 0),
-            input_tokens=len(user_message.split()) * 2,
-            output_tokens=len(final_response["response"].get("content", "").split()) * 2
-        )
-        
         return final_response
         
     except Exception as e:
@@ -1718,111 +1633,7 @@ async def startup_message():
     else:
         logger.warning("⚠️ OpenRouter endpoints not available")
 
-# ============================================================================
-# Multi-Agent Chat History Persistence Endpoints
-# ============================================================================
-
-@app.get("/api/v1/multi-agent/history")
-async def get_chat_history(session_id: str = "default", limit: int = 5):
-    """Get the last N messages from multi-agent chat history"""
-    try:
-        from database.models import DBMultiAgentMessage
-        from database.connection import db_manager
-        from sqlalchemy import desc, select
-        
-        async with db_manager.get_async_session() as session:
-            stmt = (
-                select(DBMultiAgentMessage)
-                .where(DBMultiAgentMessage.session_id == session_id)
-                .order_by(desc(DBMultiAgentMessage.created_at))
-                .limit(limit)
-            )
-            result = await session.execute(stmt)
-            messages = result.scalars().all()
-            
-            return {
-                "messages": [msg.to_dict() for msg in reversed(messages)],
-                "count": len(messages),
-                "session_id": session_id
-            }
-    except Exception as e:
-        logger.error(f"❌ Chat History Error: {e}")
-        return {"messages": [], "count": 0, "session_id": session_id, "error": str(e)}
-
-
-@app.post("/api/v1/multi-agent/history/message")
-async def save_chat_message(message: dict):
-    """Save a single message to the multi-agent chat history"""
-    try:
-        from database.models import DBMultiAgentMessage
-        from database.connection import db_manager
-        
-        async with db_manager.get_async_session() as session:
-            cost_str = message.get("cost")
-            cost_float = None
-            if cost_str and isinstance(cost_str, str):
-                cost_float = float(cost_str.replace("$", ""))
-            elif cost_str:
-                cost_float = float(cost_str)
-            
-            db_message = DBMultiAgentMessage(
-                session_id=message.get("session_id", "default"),
-                content=message.get("content", ""),
-                agent_id=message.get("agent", "unknown"),
-                agent_name=message.get("agentName", "Unknown"),
-                message_type=message.get("type", "agent"),
-                role=message.get("role"),
-                provider=message.get("provider"),
-                processing_time=message.get("processingTime"),
-                cost_usd=cost_float
-            )
-            session.add(db_message)
-            await session.commit()
-            await session.refresh(db_message)
-            
-            return {"success": True, "message_id": db_message.id}
-    except Exception as e:
-        logger.error(f"❌ Save Message Error: {e}")
-        return {"success": False, "error": str(e)}
-
-
-@app.delete("/api/v1/multi-agent/history")
-async def clear_chat_history(session_id: str = "default"):
-    """Clear chat history for a session"""
-    try:
-        from database.models import DBMultiAgentMessage
-        from database.connection import db_manager
-        from sqlalchemy import delete
-        
-        async with db_manager.get_async_session() as session:
-            stmt = delete(DBMultiAgentMessage).where(DBMultiAgentMessage.session_id == session_id)
-            await session.execute(stmt)
-            await session.commit()
-            
-            return {"success": True, "session_id": session_id}
-    except Exception as e:
-        logger.error(f"❌ Clear History Error: {e}")
-        return {"success": False, "error": str(e)}
-
-
 # ==========================================
 # NOTE: No if __name__ == "__main__" block needed
 # Supervisor/Uvicorn will start the app directly
 # ==========================================
-
-# =====================================================
-# STATIC FILES - Serve Vue.js Frontend (SPA Mode)
-# ⚠️ CRITICAL: Must be AFTER all API routes!
-# =====================================================
-
-# Import custom SPA Static Files handler
-from spa_static_files import SPAStaticFiles
-
-# Mount static files for frontend (must be AFTER all API routes)
-# SPAStaticFiles preserves API routes while serving Vue.js SPA
-frontend_dist = "/app/frontend/dist"
-if os.path.exists(frontend_dist):
-    app.mount("/", SPAStaticFiles(directory=frontend_dist, html=True), name="static")
-    logger.info(f"✅ SPA Static files mounted: {frontend_dist}")
-else:
-    logger.warning(f"⚠️ Frontend dist directory not found: {frontend_dist}")

backend/multi_agent_coordinator.py

@@ -0,0 +1,606 @@
+#!/usr/bin/env python3
+"""
+Multi-Agent Coordinator Service for SAAP Platform
+Enables autonomous agent-to-agent communication and task delegation
+"""
+
+import asyncio
+import json
+import logging
+import time
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Tuple
+from enum import Enum
+from dataclasses import dataclass
+
+import redis.asyncio as aioredis
+from pydantic import BaseModel
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class TaskStatus(str, Enum):
+    CREATED = "created"
+    ASSIGNED = "assigned"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+class TaskPriority(str, Enum):
+    LOW = "low"
+    NORMAL = "normal"
+    HIGH = "high"
+    URGENT = "urgent"
+
+@dataclass
+class AgentCapability:
+    """Agent capability definition for intelligent task matching"""
+    name: str
+    description: str
+    keywords: List[str]
+    complexity_level: int  # 1-10 scale
+
+class TaskRequest(BaseModel):
+    task_id: str
+    task_type: str
+    description: str
+    input_data: Dict[str, Any]
+    priority: TaskPriority = TaskPriority.NORMAL
+    status: TaskStatus = TaskStatus.CREATED
+    assigned_agent: Optional[str] = None
+    parent_task_id: Optional[str] = None
+    max_execution_time: int = 300  # seconds
+    
+class TaskResult(BaseModel):
+    task_id: str
+    agent_id: str
+    status: TaskStatus
+    result: Dict[str, Any]
+    execution_time: float
+    timestamp: datetime
+    error_message: Optional[str] = None
+
+class MultiAgentCoordinator:
+    """
+    Multi-Agent Coordinator for autonomous task delegation and workflow orchestration
+    Jane Alesi acts as the master coordinator with intelligent agent selection
+    """
+    
+    def __init__(self, redis_host: str = "localhost", redis_port: int = 6379):
+        self.redis_host = redis_host
+        self.redis_port = redis_port
+        self.redis_client = None
+        
+        # Agent capabilities database
+        self.agent_capabilities = {
+            "jane_alesi": [
+                AgentCapability("coordination", "Master coordination and workflow management", 
+                               ["coordinate", "manage", "orchestrate", "plan"], 9),
+                AgentCapability("architecture", "System architecture and design decisions", 
+                               ["architecture", "design", "system", "structure"], 10),
+                AgentCapability("integration", "Multi-agent integration and communication", 
+                               ["integrate", "communication", "multi-agent"], 10)
+            ],
+            "john_alesi": [
+                AgentCapability("development", "Software development and coding", 
+                               ["code", "develop", "program", "software", "implementation"], 9),
+                AgentCapability("debugging", "Code debugging and troubleshooting", 
+                               ["debug", "fix", "error", "troubleshoot"], 8),
+                AgentCapability("optimization", "Performance optimization and refactoring", 
+                               ["optimize", "performance", "refactor"], 7),
+                AgentCapability("testing", "Unit testing and code quality assurance", 
+                               ["test", "quality", "validation"], 8)
+            ],
+            "lara_alesi": [
+                AgentCapability("medical_analysis", "Medical data analysis and diagnosis", 
+                               ["medical", "health", "diagnosis", "clinical"], 10),
+                AgentCapability("data_analysis", "Statistical data analysis and interpretation", 
+                               ["analysis", "statistics", "data", "interpret"], 9),
+                AgentCapability("research", "Medical research and literature review", 
+                               ["research", "study", "literature", "evidence"], 8)
+            ],
+            "justus_alesi": [
+                AgentCapability("legal_analysis", "Legal compliance and regulatory analysis", 
+                               ["legal", "compliance", "regulation", "law"], 10),
+                AgentCapability("documentation", "Legal documentation and contract review", 
+                               ["document", "contract", "review", "legal"], 9),
+                AgentCapability("risk_assessment", "Legal risk assessment and mitigation", 
+                               ["risk", "assessment", "legal", "mitigation"], 8)
+            ],
+            "theo_alesi": [
+                AgentCapability("financial_analysis", "Financial analysis and budgeting", 
+                               ["finance", "budget", "cost", "investment"], 10),
+                AgentCapability("market_analysis", "Market analysis and business intelligence", 
+                               ["market", "business", "intelligence", "analysis"], 9),
+                AgentCapability("reporting", "Financial reporting and KPI tracking", 
+                               ["report", "kpi", "tracking", "metrics"], 8)
+            ],
+            "leon_alesi": [
+                AgentCapability("system_administration", "System administration and deployment", 
+                               ["system", "admin", "deploy", "infrastructure"], 10),
+                AgentCapability("monitoring", "System monitoring and performance tracking", 
+                               ["monitor", "performance", "system", "tracking"], 9),
+                AgentCapability("security", "System security and access control", 
+                               ["security", "access", "control", "protect"], 9)
+            ],
+            "luna_alesi": [
+                AgentCapability("coaching", "Team coaching and development", 
+                               ["coach", "team", "development", "training"], 10),
+                AgentCapability("process_improvement", "Process optimization and workflow improvement", 
+                               ["process", "improvement", "workflow", "optimize"], 8),
+                AgentCapability("communication", "Team communication and collaboration", 
+                               ["communication", "collaboration", "team"], 9)
+            ]
+        }
+        
+        # Active tasks tracking
+        self.active_tasks: Dict[str, TaskRequest] = {}
+        self.completed_tasks: Dict[str, TaskResult] = {}
+        
+        # Agent manager reference (will be injected)
+        self.agent_manager = None
+        
+    async def initialize(self):
+        """Initialize Redis connection and coordinator"""
+        try:
+            self.redis_client = aioredis.from_url(f"redis://{self.redis_host}:{self.redis_port}")
+            await self.redis_client.ping()
+            logger.info(f"✅ Multi-Agent Coordinator initialized with Redis at {self.redis_host}:{self.redis_port}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Failed to initialize Multi-Agent Coordinator: {e}")
+            return False
+    
+    def set_agent_manager(self, agent_manager):
+        """Inject agent manager dependency"""
+        self.agent_manager = agent_manager
+    
+    async def analyze_intent(self, user_message: str) -> Tuple[str, List[str], str]:
+        """
+        Analyze user intent and determine if multi-agent coordination is needed
+        Returns: (task_type, required_capabilities, primary_agent)
+        """
+        message_lower = user_message.lower()
+        
+        # Intent analysis patterns - 🎯 ENHANCED FOR FINANCIAL
+        intent_patterns = {
+            "development": ["entwicke", "code", "programmier", "implementier", "software", "app"],
+            "medical": ["medizinisch", "gesundheit", "diagnose", "patient", "clinical"],
+            "legal": ["rechtlich", "legal", "compliance", "vertrag", "regulation"],
+            "financial": ["finanzanwendung", "finanz", "finanziell", "budget", "kosten", "investment", "market", "banking", "payment"],  # 🔧 FIXED
+            "system": ["system", "deploy", "server", "infrastructure", "admin"],
+            "coordination": ["koordinier", "manage", "plan", "orchestrat", "workflow"],
+            "analysis": ["analysier", "untersuche", "bewerte", "statistik"]
+        }
+        
+        # Multi-agent patterns (require coordination)
+        multi_agent_patterns = [
+            "full stack", "complete solution", "end-to-end", "comprehensive",
+            "multi", "various", "different aspects", "holistic approach"
+        ]
+        
+        detected_intents = []
+        for intent, keywords in intent_patterns.items():
+            if any(keyword in message_lower for keyword in keywords):
+                detected_intents.append(intent)
+        
+        # Check if multi-agent coordination is needed
+        needs_coordination = any(pattern in message_lower for pattern in multi_agent_patterns) or len(detected_intents) > 1
+        
+        if needs_coordination or "coordination" in detected_intents:
+            return "multi_agent_task", detected_intents, "jane_alesi"
+        elif "development" in detected_intents:
+            return "development_task", ["development"], "john_alesi" 
+        elif "medical" in detected_intents:
+            return "medical_task", ["medical_analysis"], "lara_alesi"
+        elif "legal" in detected_intents:
+            return "legal_task", ["legal_analysis"], "justus_alesi"
+        elif "financial" in detected_intents:
+            return "financial_task", ["financial_analysis"], "theo_alesi"  # 🔧 THEO HANDLES FINANCE
+        elif "system" in detected_intents:
+            return "system_task", ["system_administration"], "leon_alesi"
+        else:
+            return "general_task", ["coordination"], "jane_alesi"
+    
+    def select_agents_for_capabilities(self, required_capabilities: List[str], exclude_agent: str = None) -> List[str]:
+        """
+        Select best agents for required capabilities
+        """
+        agent_scores = {}
+        
+        for agent_id, capabilities in self.agent_capabilities.items():
+            if exclude_agent and agent_id == exclude_agent:
+                continue
+                
+            total_score = 0
+            matched_capabilities = 0
+            
+            for required_cap in required_capabilities:
+                best_match_score = 0
+                for capability in capabilities:
+                    # Check keyword matches
+                    keyword_matches = sum(1 for keyword in capability.keywords 
+                                        if keyword in required_cap.lower())
+                    if keyword_matches > 0:
+                        match_score = keyword_matches * capability.complexity_level
+                        best_match_score = max(best_match_score, match_score)
+                
+                if best_match_score > 0:
+                    total_score += best_match_score
+                    matched_capabilities += 1
+            
+            if matched_capabilities > 0:
+                # Average score weighted by coverage
+                agent_scores[agent_id] = (total_score / len(required_capabilities)) * (matched_capabilities / len(required_capabilities))
+        
+        # Return top agents sorted by score
+        sorted_agents = sorted(agent_scores.items(), key=lambda x: x[1], reverse=True)
+        return [agent_id for agent_id, score in sorted_agents[:3]]  # Top 3 agents
+    
+    async def create_task(self, task_type: str, description: str, input_data: Dict[str, Any], 
+                         priority: TaskPriority = TaskPriority.NORMAL, 
+                         parent_task_id: str = None) -> str:
+        """Create a new task in the coordination system"""
+        task_id = str(uuid.uuid4())
+        
+        task = TaskRequest(
+            task_id=task_id,
+            task_type=task_type,
+            description=description,
+            input_data=input_data,
+            priority=priority,
+            status=TaskStatus.CREATED,
+            parent_task_id=parent_task_id
+        )
+        
+        self.active_tasks[task_id] = task
+        
+        # Store in Redis for persistence
+        if self.redis_client:
+            try:
+                await self.redis_client.hset("saap:tasks", task_id, task.json())
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to store task in Redis: {e}")
+        
+        logger.info(f"📋 Created task {task_id}: {task_type} - {description}")
+        return task_id
+    
+    async def delegate_task(self, task_id: str, agent_id: str) -> bool:
+        """Delegate a task to a specific agent"""
+        if task_id not in self.active_tasks:
+            logger.error(f"❌ Task {task_id} not found")
+            return False
+        
+        task = self.active_tasks[task_id]
+        task.assigned_agent = agent_id
+        task.status = TaskStatus.ASSIGNED
+        
+        # Update Redis
+        if self.redis_client:
+            try:
+                await self.redis_client.hset("saap:tasks", task_id, task.json())
+            except Exception as e:
+                logger.warning(f"⚠️ Failed to update task in Redis: {e}")
+        
+        logger.info(f"👤 Delegated task {task_id} to {agent_id}")
+        return True
+    
+    async def execute_task(self, task_id: str) -> TaskResult:
+        """Execute a delegated task through the assigned agent"""
+        if task_id not in self.active_tasks:
+            raise ValueError(f"Task {task_id} not found")
+        
+        task = self.active_tasks[task_id]
+        if not task.assigned_agent:
+            raise ValueError(f"Task {task_id} has no assigned agent")
+        
+        start_time = time.time()
+        task.status = TaskStatus.IN_PROGRESS
+        
+        try:
+            # Get agent and execute task
+            if not self.agent_manager:
+                raise ValueError("Agent manager not available")
+            
+            # 🔧 FIX: Don't await synchronous methods
+            agent = self.agent_manager.get_agent(task.assigned_agent)
+            if not agent:
+                raise ValueError(f"Agent {task.assigned_agent} not found")
+            
+            # Create task-specific prompt
+            task_prompt = self._create_task_prompt(task)
+            
+            # 🔧 FIX: Check if send_message is async or sync
+            if hasattr(self.agent_manager, 'send_message'):
+                # Try to determine if it's async
+                send_method = getattr(self.agent_manager, 'send_message')
+                if asyncio.iscoroutinefunction(send_method):
+                    response = await self.agent_manager.send_message(task.assigned_agent, task_prompt)
+                else:
+                    response = self.agent_manager.send_message(task.assigned_agent, task_prompt)
+            else:
+                # Fallback: Use a generic message
+                response = f"Als Master Coordinator habe ich deine Anfrage analysiert und das beste Ergebnis koordiniert."
+            
+            execution_time = time.time() - start_time
+            
+            result = TaskResult(
+                task_id=task_id,
+                agent_id=task.assigned_agent,
+                status=TaskStatus.COMPLETED,
+                result={"response": response, "execution_time": execution_time},
+                execution_time=execution_time,
+                timestamp=datetime.now()
+            )
+            
+            # Move to completed tasks
+            self.completed_tasks[task_id] = result
+            del self.active_tasks[task_id]
+            
+            # Update Redis
+            if self.redis_client:
+                try:
+                    await self.redis_client.hset("saap:completed_tasks", task_id, result.json())
+                    await self.redis_client.hdel("saap:tasks", task_id)
+                except Exception as e:
+                    logger.warning(f"⚠️ Failed to update Redis: {e}")
+            
+            logger.info(f"✅ Completed task {task_id} in {execution_time:.2f}s")
+            return result
+            
+        except Exception as e:
+            execution_time = time.time() - start_time
+            error_result = TaskResult(
+                task_id=task_id,
+                agent_id=task.assigned_agent,
+                status=TaskStatus.FAILED,
+                result={"error": str(e)},
+                execution_time=execution_time,
+                timestamp=datetime.now(),
+                error_message=str(e)
+            )
+            
+            self.completed_tasks[task_id] = error_result
+            del self.active_tasks[task_id]
+            
+            logger.error(f"❌ Task {task_id} failed: {e}")
+            return error_result
+    
+    def _create_task_prompt(self, task: TaskRequest) -> str:
+        """Create agent-specific prompt for task execution"""
+        prompt = f"""
+Task ID: {task.task_id}
+Task Type: {task.task_type}
+Priority: {task.priority}
+
+Description: {task.description}
+
+Input Data: {json.dumps(task.input_data, indent=2)}
+
+Please process this task according to your role and capabilities. 
+Provide a detailed response with actionable results.
+"""
+        return prompt
+    
+    async def coordinate_multi_agent_task(self, user_message: str, user_context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        Main coordination method for multi-agent tasks
+        This is the entry point for complex multi-agent workflows
+        """
+        start_time = time.time()
+        
+        try:
+            # Step 1: Analyze intent
+            task_type, required_capabilities, primary_agent = await self.analyze_intent(user_message)
+            
+            logger.info(f"🎯 Intent Analysis: {task_type} → {primary_agent} (capabilities: {required_capabilities})")
+            
+            # Step 2: Determine if multi-agent coordination is needed
+            if task_type == "multi_agent_task" or len(required_capabilities) > 1:
+                return await self._handle_multi_agent_workflow(user_message, required_capabilities, user_context)
+            else:
+                return await self._handle_single_agent_task(user_message, primary_agent, user_context)
+                
+        except Exception as e:
+            logger.error(f"❌ Coordination error: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "execution_time": time.time() - start_time
+            }
+    
+    async def _handle_single_agent_task(self, message: str, agent_id: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle simple single-agent task"""
+        start_time = time.time()
+        
+        try:
+            # Create and execute task
+            task_id = await self.create_task(
+                task_type="single_agent",
+                description=message,
+                input_data={"message": message, "context": context or {}}
+            )
+            
+            await self.delegate_task(task_id, agent_id)
+            result = await self.execute_task(task_id)
+            
+            return {
+                "success": result.status == TaskStatus.COMPLETED,
+                "task_id": task_id,
+                "coordinator": agent_id,
+                "coordinator_response": result.result.get("response", "Als Master Coordinator habe ich deine Anfrage analysiert und das beste Ergebnis koordiniert."),
+                "specialist_response": result.result.get("response", ""),
+                "execution_time": time.time() - start_time,
+                "workflow_type": "single_agent",
+                "coordination_chain": [agent_id],
+                "processing_time": result.execution_time,
+                "timestamp": result.timestamp.isoformat()
+            }
+        except Exception as e:
+            logger.error(f"❌ Single agent task failed: {e}")
+            return {
+                "success": False,
+                "coordinator": agent_id,
+                "coordinator_response": "Als Master Coordinator habe ich deine Anfrage analysiert und das beste Ergebnis koordiniert.",
+                "specialist_response": "",
+                "error": str(e),
+                "execution_time": time.time() - start_time,
+                "workflow_type": "single_agent",
+                "coordination_chain": [agent_id],
+                "processing_time": 0,
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    async def _handle_multi_agent_workflow(self, message: str, capabilities: List[str], context: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle complex multi-agent workflow with Jane as coordinator"""
+        start_time = time.time()
+        workflow_steps = []
+        
+        try:
+            # Step 1: Jane analyzes and creates coordination plan
+            coordination_task_id = await self.create_task(
+                task_type="coordination_analysis",
+                description=f"Analyze the following request and create a multi-agent coordination plan: {message}",
+                input_data={
+                    "original_message": message,
+                    "detected_capabilities": capabilities,
+                    "context": context or {}
+                },
+                priority=TaskPriority.HIGH
+            )
+            
+            await self.delegate_task(coordination_task_id, "jane_alesi")
+            coordination_result = await self.execute_task(coordination_task_id)
+            
+            workflow_steps.append({
+                "step": "coordination_analysis",
+                "agent": "jane_alesi",
+                "result": coordination_result.result,
+                "execution_time": coordination_result.execution_time
+            })
+            
+            # Step 2: Select and coordinate specialist agents
+            selected_agents = self.select_agents_for_capabilities(capabilities, exclude_agent="jane_alesi")
+            specialist_results = []
+            
+            for agent_id in selected_agents[:2]:  # Limit to 2 specialists for now
+                specialist_task_id = await self.create_task(
+                    task_type="specialist_analysis",
+                    description=f"Provide specialist analysis for: {message}",
+                    input_data={
+                        "original_message": message,
+                        "coordination_plan": coordination_result.result,
+                        "context": context or {}
+                    },
+                    parent_task_id=coordination_task_id
+                )
+                
+                await self.delegate_task(specialist_task_id, agent_id)
+                specialist_result = await self.execute_task(specialist_task_id)
+                
+                specialist_results.append(specialist_result)
+                workflow_steps.append({
+                    "step": "specialist_analysis",
+                    "agent": agent_id,
+                    "result": specialist_result.result,
+                    "execution_time": specialist_result.execution_time
+                })
+            
+            # Step 3: Jane synthesizes all results
+            synthesis_task_id = await self.create_task(
+                task_type="result_synthesis",
+                description="Synthesize specialist results into comprehensive response",
+                input_data={
+                    "original_message": message,
+                    "coordination_result": coordination_result.result,
+                    "specialist_results": [r.result for r in specialist_results],
+                    "context": context or {}
+                },
+                priority=TaskPriority.HIGH,
+                parent_task_id=coordination_task_id
+            )
+            
+            await self.delegate_task(synthesis_task_id, "jane_alesi")
+            synthesis_result = await self.execute_task(synthesis_task_id)
+            
+            workflow_steps.append({
+                "step": "result_synthesis",
+                "agent": "jane_alesi",
+                "result": synthesis_result.result,
+                "execution_time": synthesis_result.execution_time
+            })
+            
+            total_execution_time = time.time() - start_time
+            
+            return {
+                "success": True,
+                "workflow_type": "multi_agent",
+                "coordinator": "jane_alesi",
+                "specialists": selected_agents[:2],
+                "workflow_steps": workflow_steps,
+                "coordinator_response": "Als Master Coordinator habe ich deine Anfrage analysiert und das beste Ergebnis koordiniert.",
+                "specialist_response": synthesis_result.result.get("response", ""),
+                "final_response": synthesis_result.result.get("response", ""),
+                "coordination_chain": ["jane_alesi"] + selected_agents[:2],
+                "processing_time": total_execution_time,
+                "timestamp": datetime.now().isoformat(),
+                "task_count": len(workflow_steps)
+            }
+            
+        except Exception as e:
+            logger.error(f"❌ Multi-agent workflow failed: {e}")
+            return {
+                "success": False,
+                "workflow_type": "multi_agent",
+                "coordinator": "jane_alesi",
+                "coordinator_response": "Als Master Coordinator habe ich deine Anfrage analysiert und das beste Ergebnis koordiniert.",
+                "specialist_response": "",
+                "error": str(e),
+                "coordination_chain": ["jane_alesi"],
+                "processing_time": time.time() - start_time,
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    async def get_agent_workload(self, agent_id: str) -> Dict[str, Any]:
+        """Get current workload statistics for an agent"""
+        active_count = sum(1 for task in self.active_tasks.values() 
+                          if task.assigned_agent == agent_id)
+        completed_count = sum(1 for result in self.completed_tasks.values() 
+                             if result.agent_id == agent_id)
+        
+        return {
+            "agent_id": agent_id,
+            "active_tasks": active_count,
+            "completed_tasks": completed_count,
+            "capabilities": [cap.name for cap in self.agent_capabilities.get(agent_id, [])]
+        }
+    
+    async def get_coordination_stats(self) -> Dict[str, Any]:
+        """Get overall coordination statistics"""
+        return {
+            "active_tasks": len(self.active_tasks),
+            "completed_tasks": len(self.completed_tasks),
+            "available_agents": len(self.agent_capabilities),
+            "agent_workloads": {
+                agent_id: await self.get_agent_workload(agent_id)
+                for agent_id in self.agent_capabilities.keys()
+            }
+        }
+    
+    async def cleanup(self):
+        """Cleanup Redis connections"""
+        if self.redis_client:
+            await self.redis_client.close()
+
+# Global coordinator instance
+coordinator_instance = None
+
+async def get_coordinator() -> MultiAgentCoordinator:
+    """Get global coordinator instance"""
+    global coordinator_instance
+    if coordinator_instance is None:
+        coordinator_instance = MultiAgentCoordinator()
+        await coordinator_instance.initialize()
+    return coordinator_instance

backend/openrouter_integration.py

@@ -0,0 +1,252 @@
+"""
+OpenRouter Integration for existing SAAP AgentManagerService
+Simple integration that extends existing functionality without breaking anything
+"""
+
+import asyncio
+import logging
+import time
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+import aiohttp
+import json
+
+logger = logging.getLogger(__name__)
+
+class OpenRouterIntegration:
+    """
+    Simple OpenRouter integration for existing SAAP system
+    Designed to work alongside existing colossus integration
+    """
+    
+    def __init__(self, api_key: str = "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"):
+        self.api_key = api_key
+        self.base_url = "https://openrouter.ai/api/v1"
+        self.session: Optional[aiohttp.ClientSession] = None
+        
+        # Simple agent model mapping
+        self.agent_models = {
+            "jane_alesi": {
+                "model": "openai/gpt-4o-mini",
+                "max_tokens": 800,
+                "temperature": 0.7,
+                "cost_per_1m_input": 0.15,
+                "cost_per_1m_output": 0.60
+            },
+            "john_alesi": {
+                "model": "anthropic/claude-3-5-sonnet-20241022",
+                "max_tokens": 1200,
+                "temperature": 0.5,
+                "cost_per_1m_input": 3.00,
+                "cost_per_1m_output": 15.00
+            },
+            "lara_alesi": {
+                "model": "openai/gpt-4o-mini",
+                "max_tokens": 1000,
+                "temperature": 0.3,
+                "cost_per_1m_input": 0.15,
+                "cost_per_1m_output": 0.60
+            }
+        }
+        
+        self.daily_cost = 0.0
+        self.requests_count = 0
+        
+        logger.info(f"🌐 OpenRouter integration initialized for {len(self.agent_models)} agents")
+    
+    async def __aenter__(self):
+        """Initialize session"""
+        self.session = aiohttp.ClientSession(
+            headers={
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "https://saap.satware.ai",
+                "X-Title": "SAAP Agent Platform"
+            },
+            timeout=aiohttp.ClientTimeout(total=30)
+        )
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Close session"""
+        if self.session:
+            await self.session.close()
+    
+    async def send_message(self, agent_id: str, message: str, system_prompt: str = "") -> Dict[str, Any]:
+        """
+        Send message to OpenRouter for specific agent
+        Returns response in same format as colossus for compatibility
+        """
+        if not self.session:
+            return {
+                "error": "OpenRouter session not initialized",
+                "provider": "openrouter"
+            }
+        
+        # Get agent config or use default
+        config = self.agent_models.get(agent_id, {
+            "model": "meta-llama/llama-3.2-3b-instruct:free",
+            "max_tokens": 600,
+            "temperature": 0.7,
+            "cost_per_1m_input": 0.0,
+            "cost_per_1m_output": 0.0
+        })
+        
+        # Prepare messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": message})
+        
+        start_time = time.time()
+        
+        try:
+            payload = {
+                "model": config["model"],
+                "messages": messages,
+                "max_tokens": config["max_tokens"],
+                "temperature": config["temperature"]
+            }
+            
+            async with self.session.post(f"{self.base_url}/chat/completions", json=payload) as response:
+                response_time = time.time() - start_time
+                
+                if response.status == 200:
+                    data = await response.json()
+                    
+                    # Extract content
+                    content = ""
+                    if "choices" in data and len(data["choices"]) > 0:
+                        choice = data["choices"][0]
+                        if "message" in choice and "content" in choice["message"]:
+                            content = choice["message"]["content"]
+                    
+                    # Calculate cost
+                    usage = data.get("usage", {})
+                    input_tokens = usage.get("prompt_tokens", 0)
+                    output_tokens = usage.get("completion_tokens", 0)
+                    total_tokens = usage.get("total_tokens", 0)
+                    
+                    cost_usd = (
+                        (input_tokens / 1_000_000) * config["cost_per_1m_input"] +
+                        (output_tokens / 1_000_000) * config["cost_per_1m_output"]
+                    )
+                    
+                    # Update tracking
+                    self.daily_cost += cost_usd
+                    self.requests_count += 1
+                    
+                    logger.info(f"✅ OpenRouter success: {agent_id} via {config['model']} - {response_time:.2f}s, ${cost_usd:.6f}")
+                    
+                    return {
+                        "content": content,
+                        "response_time": response_time,
+                        "tokens_used": total_tokens,
+                        "cost_usd": cost_usd,
+                        "provider": "openrouter",
+                        "model": config["model"],
+                        "timestamp": datetime.utcnow().isoformat()
+                    }
+                else:
+                    error_text = await response.text()
+                    logger.error(f"❌ OpenRouter error: HTTP {response.status} - {error_text}")
+                    return {
+                        "error": f"OpenRouter API error: HTTP {response.status}",
+                        "provider": "openrouter",
+                        "response_time": response_time
+                    }
+        
+        except Exception as e:
+            response_time = time.time() - start_time
+            logger.error(f"❌ OpenRouter request failed: {e}")
+            return {
+                "error": f"OpenRouter request failed: {str(e)}",
+                "provider": "openrouter",
+                "response_time": response_time
+            }
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Simple health check"""
+        if not self.session:
+            return {"status": "unhealthy", "error": "Session not initialized"}
+        
+        try:
+            result = await self.send_message("test", "Say 'OK'", "Reply with just 'OK'")
+            return {
+                "status": "healthy" if "error" not in result else "unhealthy",
+                "response_time": result.get("response_time", 0),
+                "error": result.get("error"),
+                "daily_cost": self.daily_cost,
+                "requests_count": self.requests_count
+            }
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get simple statistics"""
+        return {
+            "provider": "openrouter",
+            "daily_cost_usd": round(self.daily_cost, 6),
+            "total_requests": self.requests_count,
+            "avg_cost_per_request": round(self.daily_cost / max(1, self.requests_count), 6),
+            "available_agents": list(self.agent_models.keys()),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+
+
+# Global instance for easy import
+_openrouter_instance = None
+
+async def get_openrouter() -> OpenRouterIntegration:
+    """Get or create OpenRouter instance"""
+    global _openrouter_instance
+    
+    if _openrouter_instance is None:
+        _openrouter_instance = OpenRouterIntegration()
+        await _openrouter_instance.__aenter__()
+    
+    return _openrouter_instance
+
+async def send_openrouter_message(agent_id: str, message: str, system_prompt: str = "") -> Dict[str, Any]:
+    """Convenient function to send message via OpenRouter"""
+    try:
+        openrouter = await get_openrouter()
+        return await openrouter.send_message(agent_id, message, system_prompt)
+    except Exception as e:
+        logger.error(f"❌ OpenRouter message failed: {e}")
+        return {
+            "error": f"OpenRouter integration error: {str(e)}",
+            "provider": "openrouter"
+        }
+
+async def cleanup_openrouter():
+    """Cleanup OpenRouter resources"""
+    global _openrouter_instance
+    if _openrouter_instance:
+        await _openrouter_instance.__aexit__(None, None, None)
+        _openrouter_instance = None
+        logger.info("🌐 OpenRouter integration cleaned up")
+
+
+if __name__ == "__main__":
+    # Quick test
+    async def test_integration():
+        async with OpenRouterIntegration() as openrouter:
+            print("🧪 Testing OpenRouter integration...")
+            
+            health = await openrouter.health_check()
+            print(f"Health: {health}")
+            
+            if health["status"] == "healthy":
+                result = await openrouter.send_message("jane_alesi", "Hello! Tell me about multi-agent systems in one sentence.")
+                print(f"Response: {result.get('content', 'No content')}")
+                print(f"Cost: ${result.get('cost_usd', 0):.6f}")
+                print(f"Time: {result.get('response_time', 0):.2f}s")
+            
+            stats = openrouter.get_stats()
+            print(f"Stats: {stats}")
+    
+    asyncio.run(test_integration())

backend/privacy_detector.py

@@ -0,0 +1,288 @@
+"""
+Privacy Detector for SAAP Multi-Agent System
+Detects sensitive data to route to local colossus instead of external OpenRouter
+"""
+
+import re
+import logging
+from typing import Dict, List, Tuple
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+class PrivacyLevel(Enum):
+    """Privacy classification levels"""
+    PUBLIC = "public"  # Safe for external processing
+    INTERNAL = "internal"  # Prefer local but not critical
+    CONFIDENTIAL = "confidential"  # Should be local
+    PRIVATE = "private"  # MUST be local (medical, financial, personal)
+
+class PrivacyDetector:
+    """
+    Detects sensitive data in user messages to ensure privacy-compliant routing
+    
+    Detection Methods:
+    1. Keyword-based (medical, financial, personal data keywords)
+    2. Pattern-based (credit cards, SSN, IBAN, etc.)
+    3. Agent-based rules (medical agent = always private)
+    """
+    
+    def __init__(self):
+        # Sensitive keyword categories
+        self.sensitive_keywords = {
+            "medical": [
+                "patient", "patienten", "diagnosis", "diagnose", "treatment", "behandlung",
+                "medication", "medikament", "symptom", "krankheit", "disease", "arzt",
+                "doctor", "hospital", "krankenhaus", "gesundheit", "health", "medizin",
+                "medicine", "therapie", "therapy", "blut", "blood", "operation"
+            ],
+            "financial": [
+                # Only TRULY sensitive financial data (account numbers, cards, passwords)
+                # General financial advice keywords removed (investment, portfolio, sparen, etc.)
+                "account number", "kontonummer", "password", "passwort", 
+                "credit card", "kreditkarte", "iban", "bic", 
+                "pin", "cvv", "security code", "sicherheitscode",
+                "salary", "gehalt",  # Personal income data
+                "tax id", "steuernummer"  # Personal tax data
+            ],
+            "personal": [
+                "social security", "sozialversicherung", "passport", "reisepass",
+                "driver license", "führerschein", "birthday", "geburtstag", "geburtsdatum",
+                "address", "adresse", "phone", "telefon", "email", "personalausweis",
+                "id card", "tax", "steuer", "insurance", "versicherung"
+            ],
+            "legal": [
+                "contract", "vertrag", "confidential", "vertraulich", "proprietary",
+                "nda", "geheimhaltung", "lawsuit", "klage", "court", "gericht",
+                "lawyer", "anwalt", "legal", "rechtlich"
+            ],
+            "security": [
+                "secret", "geheim", "private key", "token", "api key", "credentials",
+                "zugangsdaten", "authentication", "authentifizierung"
+            ]
+        }
+        
+        # Sensitive data patterns (regex)
+        self.sensitive_patterns = [
+            # Credit card numbers
+            (r"\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b", "credit_card"),
+            # SSN (US)
+            (r"\b\d{3}-\d{2}-\d{4}\b", "ssn"),
+            # IBAN
+            (r"\b[A-Z]{2}\d{2}[A-Z0-9]{13,29}\b", "iban"),
+            # Dates (potential birthdays)
+            (r"\b\d{2}[./]\d{2}[./]\d{4}\b", "date"),
+            # Email addresses
+            (r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b", "email"),
+            # Phone numbers (German format)
+            (r"\b(?:\+49|0)\s?\d{3,4}\s?\d{6,8}\b", "phone"),
+            # API keys/tokens (long alphanumeric strings)
+            (r"\b[A-Za-z0-9]{32,}\b", "api_key")
+        ]
+        
+        # Agent-specific privacy rules
+        # Only MANDATORY privacy rules here (content-based detection is preferred)
+        self.agent_privacy_rules = {
+            "lara_alesi": PrivacyLevel.PRIVATE,  # Medical - ALWAYS private (health data)
+            "theo_alesi": PrivacyLevel.INTERNAL,  # Financial - depends on content
+            "justus_alesi": PrivacyLevel.INTERNAL,  # Legal - depends on content
+            "jane_alesi": PrivacyLevel.INTERNAL,  # Coordinator - depends on content
+            "john_alesi": PrivacyLevel.INTERNAL,  # Development - usually safe
+            "leon_alesi": PrivacyLevel.INTERNAL,  # System - usually safe
+            "luna_alesi": PrivacyLevel.INTERNAL  # Coaching - usually safe
+        }
+        
+    def detect_privacy_level(
+        self, 
+        message: str, 
+        agent_id: str = None,
+        user_privacy_flag: str = None
+    ) -> Tuple[PrivacyLevel, Dict]:
+        """
+        Detect privacy level of message
+        
+        Args:
+            message: User message to analyze
+            agent_id: Agent that will process this (optional)
+            user_privacy_flag: User-specified privacy level (optional)
+            
+        Returns:
+            Tuple of (PrivacyLevel, detection_details)
+        """
+        
+        # User override takes precedence
+        if user_privacy_flag:
+            level = self._parse_user_privacy_flag(user_privacy_flag)
+            return level, {"reason": "user_override", "user_flag": user_privacy_flag}
+        
+        # Check agent-specific rules first
+        if agent_id and agent_id in self.agent_privacy_rules:
+            agent_level = self.agent_privacy_rules[agent_id]
+            if agent_level == PrivacyLevel.PRIVATE:
+                return agent_level, {
+                    "reason": "agent_rule",
+                    "agent": agent_id,
+                    "rule": "always_private"
+                }
+        
+        # Keyword detection
+        keyword_matches = self._detect_keywords(message)
+        
+        # Pattern detection
+        pattern_matches = self._detect_patterns(message)
+        
+        # Combine detections
+        total_detections = len(keyword_matches) + len(pattern_matches)
+        
+        # Determine privacy level based on detections
+        details = {
+            "keyword_matches": keyword_matches,
+            "pattern_matches": pattern_matches,
+            "total_detections": total_detections
+        }
+        
+        # Classification logic
+        if pattern_matches:  # Any pattern match = high sensitivity
+            if any(cat in ["credit_card", "ssn", "iban"] for pat, cat in pattern_matches):
+                return PrivacyLevel.PRIVATE, {**details, "reason": "sensitive_pattern"}
+        
+        if keyword_matches:
+            categories = set(cat for cat, _ in keyword_matches)
+            
+            # Medical or financial keywords = PRIVATE
+            if "medical" in categories or "financial" in categories:
+                return PrivacyLevel.PRIVATE, {**details, "reason": "sensitive_keywords"}
+            
+            # Personal or legal = CONFIDENTIAL
+            if "personal" in categories or "legal" in categories:
+                return PrivacyLevel.CONFIDENTIAL, {**details, "reason": "confidential_keywords"}
+            
+            # Security keywords = CONFIDENTIAL
+            if "security" in categories:
+                return PrivacyLevel.CONFIDENTIAL, {**details, "reason": "security_keywords"}
+        
+        # Apply agent rule if no strong detection
+        if agent_id and agent_id in self.agent_privacy_rules:
+            return self.agent_privacy_rules[agent_id], {
+                **details,
+                "reason": "agent_default",
+                "agent": agent_id
+            }
+        
+        # Default: PUBLIC (safe for external processing)
+        return PrivacyLevel.PUBLIC, {**details, "reason": "no_sensitive_data"}
+    
+    def _detect_keywords(self, message: str) -> List[Tuple[str, str]]:
+        """Detect sensitive keywords in message using word boundaries"""
+        message_lower = message.lower()
+        matches = []
+        
+        for category, keywords in self.sensitive_keywords.items():
+            for keyword in keywords:
+                # Use word boundaries to avoid false positives
+                # "health" in "wealth" won't match
+                pattern = r'\b' + re.escape(keyword) + r'\b'
+                if re.search(pattern, message_lower):
+                    matches.append((category, keyword))
+        
+        return matches
+    
+    def _detect_patterns(self, message: str) -> List[Tuple[str, str]]:
+        """Detect sensitive patterns in message"""
+        matches = []
+        
+        for pattern, category in self.sensitive_patterns:
+            if re.search(pattern, message):
+                matches.append((pattern, category))
+        
+        return matches
+    
+    def _parse_user_privacy_flag(self, flag: str) -> PrivacyLevel:
+        """Parse user-specified privacy flag"""
+        flag_lower = flag.lower()
+        
+        if flag_lower in ["private", "high", "strict"]:
+            return PrivacyLevel.PRIVATE
+        elif flag_lower in ["confidential", "medium"]:
+            return PrivacyLevel.CONFIDENTIAL
+        elif flag_lower in ["internal", "low"]:
+            return PrivacyLevel.INTERNAL
+        else:
+            return PrivacyLevel.PUBLIC
+    
+    def should_use_local_provider(self, privacy_level: PrivacyLevel, mode: str = "balanced") -> bool:
+        """
+        Determine if local provider should be used based on privacy level and mode
+        
+        Args:
+            privacy_level: Detected privacy level
+            mode: Privacy mode (strict, balanced, performance)
+            
+        Returns:
+            True if should use local provider (colossus), False if external OK (OpenRouter)
+        """
+        
+        if mode == "strict":
+            # Strict: Everything goes local
+            return True
+        
+        elif mode == "balanced":
+            # Balanced: Private and Confidential go local
+            return privacy_level in [PrivacyLevel.PRIVATE, PrivacyLevel.CONFIDENTIAL]
+        
+        elif mode == "performance":
+            # Performance: Only explicitly PRIVATE goes local
+            return privacy_level == PrivacyLevel.PRIVATE
+        
+        else:
+            # Default to balanced
+            return privacy_level in [PrivacyLevel.PRIVATE, PrivacyLevel.CONFIDENTIAL]
+
+
+# Singleton instance
+privacy_detector = PrivacyDetector()
+
+
+# Convenience functions
+def detect_privacy_level(message: str, agent_id: str = None, user_flag: str = None) -> Tuple[PrivacyLevel, Dict]:
+    """Convenience function to detect privacy level"""
+    return privacy_detector.detect_privacy_level(message, agent_id, user_flag)
+
+
+def should_use_local(message: str, agent_id: str = None, mode: str = "balanced") -> bool:
+    """Convenience function to check if local provider should be used"""
+    level, details = privacy_detector.detect_privacy_level(message, agent_id)
+    use_local = privacy_detector.should_use_local_provider(level, mode)
+    
+    logger.info(f"Privacy check: {level.value} → {'LOCAL' if use_local else 'EXTERNAL'} ({details.get('reason', 'unknown')})")
+    
+    return use_local
+
+
+if __name__ == "__main__":
+    # Demo privacy detection
+    test_cases = [
+        ("What is Python?", "john_alesi"),
+        ("My patient has symptoms of diabetes", "lara_alesi"),
+        ("Analyze my bank account: DE89370400440532013000", "theo_alesi"),
+        ("Review this confidential contract", "justus_alesi"),
+        ("How to optimize this code?", "john_alesi"),
+        ("My credit card number is 4532-1234-5678-9010", None)
+    ]
+    
+    print("🔒 Privacy Detection Demo\n")
+    
+    for message, agent in test_cases:
+        level, details = detect_privacy_level(message, agent)
+        use_local = privacy_detector.should_use_local_provider(level, mode="balanced")
+        
+        print(f"Message: '{message[:50]}...'")
+        print(f"Agent: {agent or 'None'}")
+        print(f"Privacy Level: {level.value}")
+        print(f"Routing: {'LOCAL (colossus)' if use_local else 'EXTERNAL (OpenRouter)'}")
+        print(f"Reason: {details.get('reason')}")
+        if details.get('keyword_matches'):
+            print(f"Keywords: {details['keyword_matches']}")
+        if details.get('pattern_matches'):
+            print(f"Patterns: {details['pattern_matches']}")
+        print()

backend/requirements.txt

@@ -15,9 +15,9 @@ sqlalchemy==2.0.36  # Updated for Python 3.13 compatibility
 alembic==1.14.0  # Updated to match SQLAlchemy version
 aiosqlite==0.20.0  # Async SQLite driver (REQUIRED for async database operations)
 greenlet>=3.0.0  # Required for SQLAlchemy async operations
+psycopg2-binary==2.9.9  # PostgreSQL driver (works in Docker with Debian base)
 asyncpg==0.30.0  # Async PostgreSQL driver (Python 3.13 compatible)
-psycopg[binary]==3.2.3  # Modern PostgreSQL driver (Python 3.13 compatible, replaces psycopg2)
-# Note: Using both psycopg3 (modern) and asyncpg (async) for PostgreSQL compatibility
+# Note: Using both psycopg2 (sync) and asyncpg (async) for PostgreSQL compatibility
 
 # HTTP Clients
 httpx==0.26.0
@@ -48,10 +48,3 @@ orjson==3.9.12
 
 # CORS (handled by FastAPI's built-in CORSMiddleware)
 # No separate package needed - use fastapi.middleware.cors.CORSMiddleware
-
-# Document Processing (for file upload functionality)
-PyPDF2==3.0.1  # PDF text extraction
-python-docx==1.1.0  # DOCX/DOC text extraction
-
-# System Monitoring (for metrics endpoints)
-psutil==5.9.8  # CPU, Memory, Disk, Network monitoring

backend/service.py

@@ -0,0 +1,320 @@
+"""
+SAAP Database Service - High-level Database Operations
+Simplified database operations for Agent Manager with proper initialization
+"""
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, update, delete
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from database.connection import db_manager
+from database.models import DBAgent, DBChatMessage, DBAgentSession
+from models.agent import SaapAgent, AgentStatus
+
+logger = logging.getLogger(__name__)
+
+class DatabaseService:
+    """
+    High-level database service for SAAP Agent operations
+    Handles all database operations with proper error handling
+    """
+    
+    def __init__(self):
+        self.is_ready = False
+    
+    async def initialize(self):
+        """Initialize database service and ensure tables exist"""
+        try:
+            logger.info("🗄️ Initializing SAAP Database Service...")
+            
+            # Initialize database manager if not already done
+            if not db_manager.is_initialized:
+                await db_manager.initialize()
+            
+            # Force database tables creation
+            await self._ensure_tables_exist()
+            
+            self.is_ready = True
+            logger.info("✅ Database Service initialized successfully")
+            
+        except Exception as e:
+            logger.error(f"❌ Database Service initialization failed: {e}")
+            raise
+    
+    async def _ensure_tables_exist(self):
+        """Ensure all required database tables exist"""
+        try:
+            # Force table creation by running a simple query
+            async with db_manager.get_async_session() as session:
+                # Test if agents table exists by trying to count rows
+                try:
+                    result = await session.execute(select(DBAgent))
+                    agents = result.scalars().all()
+                    logger.info(f"📚 Found {len(agents)} existing agents in database")
+                except Exception as table_error:
+                    logger.warning(f"⚠️ Agents table not ready: {table_error}")
+                    # Tables should already be created by db_manager.initialize()
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to verify tables: {e}")
+            raise
+    
+    async def save_agent(self, agent: SaapAgent) -> bool:
+        """Save or update agent in database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                # Check if agent exists
+                existing = await session.execute(
+                    select(DBAgent).where(DBAgent.id == agent.id)
+                )
+                db_agent = existing.scalar_one_or_none()
+                
+                if db_agent:
+                    # Update existing agent
+                    for key, value in DBAgent.from_saap_agent(agent).__dict__.items():
+                        if not key.startswith('_'):  # Skip SQLAlchemy internal attributes
+                            setattr(db_agent, key, value)
+                    
+                    db_agent.updated_at = datetime.utcnow()
+                    logger.info(f"🔄 Updating existing agent: {agent.name}")
+                else:
+                    # Create new agent
+                    db_agent = DBAgent.from_saap_agent(agent)
+                    session.add(db_agent)
+                    logger.info(f"➕ Creating new agent: {agent.name}")
+                
+                await session.commit()
+                logger.info(f"✅ Agent saved successfully: {agent.name} ({agent.id})")
+                return True
+                
+        except IntegrityError as ie:
+            logger.error(f"❌ Database integrity error saving agent {agent.id}: {ie}")
+            return False
+        except Exception as e:
+            logger.error(f"❌ Failed to save agent {agent.id}: {e}")
+            return False
+    
+    async def load_agent(self, agent_id: str) -> Optional[SaapAgent]:
+        """Load agent from database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(
+                    select(DBAgent).where(DBAgent.id == agent_id)
+                )
+                db_agent = result.scalar_one_or_none()
+                
+                if db_agent:
+                    agent = db_agent.to_saap_agent()
+                    logger.debug(f"📖 Loaded agent: {agent.name}")
+                    return agent
+                else:
+                    logger.debug(f"❓ Agent not found in database: {agent_id}")
+                    return None
+                    
+        except Exception as e:
+            logger.error(f"❌ Failed to load agent {agent_id}: {e}")
+            return None
+    
+    async def load_all_agents(self) -> List[SaapAgent]:
+        """Load all agents from database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                db_agents = result.scalars().all()
+                
+                agents = []
+                for db_agent in db_agents:
+                    try:
+                        agent = db_agent.to_saap_agent()
+                        agents.append(agent)
+                    except Exception as conv_error:
+                        logger.error(f"⚠️ Failed to convert agent {db_agent.id}: {conv_error}")
+                        continue
+                
+                logger.info(f"📚 Loaded {len(agents)} agents from database")
+                return agents
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to load agents from database: {e}")
+            return []
+    
+    async def delete_agent(self, agent_id: str) -> bool:
+        """Delete agent from database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                # Delete agent (cascading will handle related records)
+                result = await session.execute(
+                    delete(DBAgent).where(DBAgent.id == agent_id)
+                )
+                
+                await session.commit()
+                
+                if result.rowcount > 0:
+                    logger.info(f"🗑️ Agent deleted from database: {agent_id}")
+                    return True
+                else:
+                    logger.warning(f"❓ Agent not found for deletion: {agent_id}")
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"❌ Failed to delete agent {agent_id}: {e}")
+            return False
+    
+    async def update_agent_status(self, agent_id: str, status: AgentStatus) -> bool:
+        """Update agent status in database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(
+                    update(DBAgent)
+                    .where(DBAgent.id == agent_id)
+                    .values(
+                        status=status.value,
+                        last_active=datetime.utcnow(),
+                        updated_at=datetime.utcnow()
+                    )
+                )
+                
+                await session.commit()
+                
+                if result.rowcount > 0:
+                    logger.debug(f"📊 Agent status updated: {agent_id} -> {status.value}")
+                    return True
+                else:
+                    logger.warning(f"❓ Agent not found for status update: {agent_id}")
+                    return False
+                    
+        except Exception as e:
+            logger.error(f"❌ Failed to update agent status {agent_id}: {e}")
+            return False
+    
+    async def save_chat_message(self, agent_id: str, user_message: str, 
+                              agent_response: str, response_time: float, 
+                              tokens_used: int = 0, metadata: Dict = None) -> bool:
+        """Save chat message to database"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                chat_message = DBChatMessage(
+                    agent_id=agent_id,
+                    user_message=user_message,
+                    agent_response=agent_response,
+                    response_time=response_time,
+                    tokens_used=tokens_used,
+                    message_metadata=metadata or {}
+                )
+                
+                session.add(chat_message)
+                await session.commit()
+                
+                logger.debug(f"💬 Chat message saved for agent: {agent_id}")
+                return True
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to save chat message for {agent_id}: {e}")
+            return False
+    
+    async def get_agent_chat_history(self, agent_id: str, limit: int = 50) -> List[Dict]:
+        """Get chat history for an agent"""
+        try:
+            if not self.is_ready:
+                await self.initialize()
+            
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(
+                    select(DBChatMessage)
+                    .where(DBChatMessage.agent_id == agent_id)
+                    .order_by(DBChatMessage.created_at.desc())
+                    .limit(limit)
+                )
+                
+                messages = result.scalars().all()
+                
+                return [
+                    {
+                        "user_message": msg.user_message,
+                        "agent_response": msg.agent_response,
+                        "response_time": msg.response_time,
+                        "tokens_used": msg.tokens_used,
+                        "created_at": msg.created_at.isoformat(),
+                        "metadata": msg.message_metadata or {}
+                    }
+                    for msg in messages
+                ]
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to get chat history for {agent_id}: {e}")
+            return []
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Check database service health"""
+        try:
+            if not db_manager.is_initialized:
+                return {"status": "not_initialized"}
+            
+            # Try to count agents
+            async with db_manager.get_async_session() as session:
+                result = await session.execute(select(DBAgent))
+                agent_count = len(result.scalars().all())
+                
+                return {
+                    "status": "healthy",
+                    "service_ready": self.is_ready,
+                    "agent_count": agent_count,
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+                
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e),
+                "service_ready": self.is_ready,
+                "timestamp": datetime.utcnow().isoformat()
+            }
+
+# Global database service instance
+database_service = DatabaseService()
+
+# Convenience functions
+async def ensure_database_ready():
+    """Ensure database service is ready"""
+    if not database_service.is_ready:
+        await database_service.initialize()
+
+if __name__ == "__main__":
+    async def test_database_service():
+        """Test database service functionality"""
+        print("🧪 Testing Database Service...")
+        
+        service = DatabaseService()
+        await service.initialize()
+        
+        # Test health check
+        health = await service.health_check()
+        print(f"Health: {health}")
+        
+        # Test loading agents
+        agents = await service.load_all_agents()
+        print(f"Loaded agents: {[a.name for a in agents]}")
+    
+    asyncio.run(test_database_service())

backend/services/privacy_detector.py

@@ -259,100 +259,6 @@ def should_use_local(message: str, agent_id: str = None, mode: str = "balanced")
     return use_local
 
 
-def analyze_document_privacy(
-    document_text: str,
-    filename: str = "",
-    agent_id: str = None
-) -> Tuple[PrivacyLevel, Dict]:
-    """
-    📄 Analyze privacy level of uploaded document content
-    
-    Args:
-        document_text: Extracted text from document (PDF, DOCX, TXT)
-        filename: Original filename (optional, for context)
-        agent_id: Agent that will process this (optional)
-        
-    Returns:
-        Tuple of (PrivacyLevel, detection_details)
-    """
-    if not document_text or not document_text.strip():
-        return PrivacyLevel.PUBLIC, {
-            "reason": "empty_document",
-            "filename": filename
-        }
-    
-    # Use same detection as messages but with document-specific context
-    level, details = privacy_detector.detect_privacy_level(document_text, agent_id)
-    
-    # Add document-specific information
-    details["source"] = "document"
-    details["filename"] = filename
-    details["content_length"] = len(document_text)
-    
-    # Additional document-specific checks
-    text_lower = document_text.lower()
-    
-    # Check for document type indicators
-    document_indicators = []
-    
-    if any(word in text_lower for word in ["medical record", "patient chart", "krankenakte", "patientenakte"]):
-        document_indicators.append("medical_record")
-        level = PrivacyLevel.PRIVATE  # Override to PRIVATE
-    
-    if any(word in text_lower for word in ["balance sheet", "bilanz", "financial statement", "finanzübersicht"]):
-        document_indicators.append("financial_statement")
-        if level.value != "private":
-            level = PrivacyLevel.CONFIDENTIAL
-    
-    if any(word in text_lower for word in ["confidential", "vertraulich", "streng vertraulich", "classified"]):
-        document_indicators.append("marked_confidential")
-        if level.value not in ["private", "confidential"]:
-            level = PrivacyLevel.CONFIDENTIAL
-    
-    if any(word in text_lower for word in ["contract", "vertrag", "agreement", "vereinbarung", "nda"]):
-        document_indicators.append("legal_document")
-        if level.value not in ["private", "confidential"]:
-            level = PrivacyLevel.CONFIDENTIAL
-    
-    if document_indicators:
-        details["document_indicators"] = document_indicators
-        details["reason"] = f"document_type: {', '.join(document_indicators)}"
-    
-    logger.info(f"📄 Document privacy analysis: {filename} → {level.value} ({details.get('reason')})")
-    
-    return level, details
-
-
-def should_use_local_for_document(
-    document_text: str,
-    filename: str = "",
-    agent_id: str = None,
-    mode: str = "balanced"
-) -> Tuple[bool, PrivacyLevel, Dict]:
-    """
-    📄 Determine if document should be processed locally
-    
-    Args:
-        document_text: Extracted document content
-        filename: Original filename
-        agent_id: Target agent (optional)
-        mode: Privacy mode (strict, balanced, performance)
-        
-    Returns:
-        Tuple of (use_local, privacy_level, details)
-    """
-    level, details = analyze_document_privacy(document_text, filename, agent_id)
-    use_local = privacy_detector.should_use_local_provider(level, mode)
-    
-    logger.info(
-        f"📄 Document routing: {filename} → "
-        f"{'LOCAL (colossus)' if use_local else 'EXTERNAL (OpenRouter)'} "
-        f"[{level.value}]"
-    )
-    
-    return use_local, level, details
-
-
 if __name__ == "__main__":
     # Demo privacy detection
     test_cases = [

backend/settings.py

@@ -0,0 +1,482 @@
+"""
+SAAP Configuration Settings - Production Ready with OpenRouter Integration
+Environment-based configuration management for On-Premise deployment
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, List
+from pydantic import Field, field_validator
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+import logging
+
+class DatabaseSettings(BaseSettings):
+    """Database configuration settings"""
+    
+    # Database URL - supports SQLite, PostgreSQL, MySQL
+    database_url: str = Field(
+        default="sqlite:///./saap_production.db",
+        env="DATABASE_URL",
+        description="Database connection URL"
+    )
+    
+    # Connection pool settings
+    pool_size: int = Field(default=10, env="DB_POOL_SIZE")
+    max_overflow: int = Field(default=20, env="DB_MAX_OVERFLOW")
+    pool_timeout: int = Field(default=30, env="DB_POOL_TIMEOUT")
+    pool_recycle: int = Field(default=3600, env="DB_POOL_RECYCLE")
+    
+    # SQLite specific
+    sqlite_check_same_thread: bool = Field(default=False, env="SQLITE_CHECK_SAME_THREAD")
+    
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+    
+    @field_validator('database_url')
+    def validate_database_url(cls, v):
+        """Ensure database URL is properly formatted"""
+        if not v.startswith(('sqlite:///', 'postgresql://', 'mysql://')):
+            raise ValueError('Unsupported database type. Use sqlite, postgresql, or mysql.')
+        return v
+
+class ColossusSettings(BaseSettings):
+    """colossus Server configuration"""
+    
+    api_base: str = Field(
+        default="https://ai.adrian-schupp.de",
+        env="COLOSSUS_API_BASE",
+        description="colossus server base URL"
+    )
+    
+    api_key: str = Field(
+        default="sk-dBoxml3krytIRLdjr35Lnw",
+        env="COLOSSUS_API_KEY",
+        description="colossus API key"
+    )
+    
+    default_model: str = Field(
+        default="mistral-small3.2:24b-instruct-2506",
+        env="COLOSSUS_DEFAULT_MODEL"
+    )
+    
+    timeout: int = Field(default=60, env="COLOSSUS_TIMEOUT")
+    max_retries: int = Field(default=3, env="COLOSSUS_MAX_RETRIES")
+    
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+
+class OpenRouterSettings(BaseSettings):
+    """OpenRouter API configuration for cost-efficient models"""
+    
+    # API Configuration
+    api_key: str = Field(
+        default="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",
+        env="OPENROUTER_API_KEY",
+        description="OpenRouter API key for cost-efficient LLM access"
+    )
+    
+    base_url: str = Field(
+        default="https://openrouter.ai/api/v1",
+        env="OPENROUTER_BASE_URL"
+    )
+    
+    enabled: bool = Field(default=True, env="OPENROUTER_ENABLED")
+    
+    # Cost Optimization Settings
+    use_cost_optimization: bool = Field(default=True, env="OPENROUTER_USE_COST_OPTIMIZATION")
+    max_cost_per_request: float = Field(default=0.01, env="OPENROUTER_MAX_COST_PER_REQUEST")
+    fallback_to_free: bool = Field(default=True, env="OPENROUTER_FALLBACK_TO_FREE")
+    
+    # Agent-Specific Model Configuration
+    jane_model: str = Field(default="openai/gpt-4o-mini", env="JANE_ALESI_MODEL")
+    jane_max_tokens: int = Field(default=800, env="JANE_ALESI_MAX_TOKENS")
+    jane_temperature: float = Field(default=0.7, env="JANE_ALESI_TEMPERATURE")
+    
+    john_model: str = Field(default="anthropic/claude-3-haiku", env="JOHN_ALESI_MODEL") 
+    john_max_tokens: int = Field(default=1200, env="JOHN_ALESI_MAX_TOKENS")
+    john_temperature: float = Field(default=0.5, env="JOHN_ALESI_TEMPERATURE")
+    
+    lara_model: str = Field(default="openai/gpt-4o-mini", env="LARA_ALESI_MODEL")
+    lara_max_tokens: int = Field(default=1000, env="LARA_ALESI_MAX_TOKENS") 
+    lara_temperature: float = Field(default=0.3, env="LARA_ALESI_TEMPERATURE")
+    
+    # Free Model Fallbacks
+    fallback_model: str = Field(default="meta-llama/llama-3.2-3b-instruct:free", env="FALLBACK_MODEL")
+    analyst_model: str = Field(default="meta-llama/llama-3.2-3b-instruct:free", env="ANALYST_MODEL")
+    
+    # Cost Tracking
+    enable_cost_tracking: bool = Field(default=True, env="ENABLE_COST_TRACKING")
+    cost_alert_threshold: float = Field(default=5.0, env="COST_ALERT_THRESHOLD")
+    log_performance_metrics: bool = Field(default=True, env="LOG_PERFORMANCE_METRICS")
+    save_cost_analytics: bool = Field(default=True, env="SAVE_COST_ANALYTICS")
+    
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"
+    }
+    
+    def get_agent_model_config(self, agent_name: str) -> dict:
+        """Get model configuration for specific agent"""
+        configs = {
+            "jane_alesi": {
+                "model": self.jane_model,
+                "max_tokens": self.jane_max_tokens,
+                "temperature": self.jane_temperature,
+                "cost_per_1m": 0.15  # GPT-4o-mini
+            },
+            "john_alesi": {
+                "model": self.john_model, 
+                "max_tokens": self.john_max_tokens,
+                "temperature": self.john_temperature,
+                "cost_per_1m": 0.25  # Claude-3-Haiku
+            },
+            "lara_alesi": {
+                "model": self.lara_model,
+                "max_tokens": self.lara_max_tokens,
+                "temperature": self.lara_temperature,
+                "cost_per_1m": 0.15  # GPT-4o-mini
+            }
+        }
+        
+        return configs.get(agent_name.lower(), {
+            "model": self.fallback_model,
+            "max_tokens": 600,
+            "temperature": 0.7,
+            "cost_per_1m": 0.0  # Free model
+        })
+    
+class RedisSettings(BaseSettings):
+    """Redis configuration for message queuing"""
+    
+    host: str = Field(default="localhost", env="REDIS_HOST")
+    port: int = Field(default=6379, env="REDIS_PORT")
+    password: Optional[str] = Field(default=None, env="REDIS_PASSWORD")
+    database: int = Field(default=0, env="REDIS_DB")
+    max_connections: int = Field(default=50, env="REDIS_MAX_CONNECTIONS")
+
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+
+class SecuritySettings(BaseSettings):
+    """Security and authentication settings"""
+    
+    secret_key: str = Field(
+        default="saap-development-secret-change-in-production",
+        env="SECRET_KEY",
+        min_length=32
+    )
+    
+    # JWT Settings
+    jwt_algorithm: str = Field(default="HS256", env="JWT_ALGORITHM")
+    jwt_expire_minutes: int = Field(default=1440, env="JWT_EXPIRE_MINUTES")  # 24 hours
+    
+    # API Rate limiting
+    rate_limit_requests: int = Field(default=1000, env="RATE_LIMIT_REQUESTS")
+    rate_limit_window: int = Field(default=3600, env="RATE_LIMIT_WINDOW")  # 1 hour
+    
+    # CORS settings - Updated for network access
+    allowed_origins: str = Field(
+        default="http://localhost:5173,http://localhost:8080,http://localhost:3000,http://100.64.0.45:5173,http://100.64.0.45:8080,http://100.64.0.45:3000,http://100.64.0.45:8000",
+        env="ALLOWED_ORIGINS"
+    )
+
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+    
+    @field_validator('allowed_origins')
+    def parse_allowed_origins(cls, v):
+        """Parse comma-separated origins string into list"""
+        if isinstance(v, str):
+            return [origin.strip() for origin in v.split(',') if origin.strip()]
+        return v
+    
+    def get_allowed_origins_list(self) -> List[str]:
+        """Get allowed origins as a list"""
+        if isinstance(self.allowed_origins, str):
+            return [origin.strip() for origin in self.allowed_origins.split(',') if origin.strip()]
+        return self.allowed_origins
+
+class LoggingSettings(BaseSettings):
+    """Enhanced logging configuration with cost tracking"""
+    
+    log_level: str = Field(default="INFO", env="LOG_LEVEL")
+    log_format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        env="LOG_FORMAT"
+    )
+    
+    # File logging
+    log_to_file: bool = Field(default=True, env="LOG_TO_FILE")
+    log_file_path: str = Field(default="logs/saap.log", env="LOG_FILE_PATH")
+    log_file_max_size: int = Field(default=10485760, env="LOG_FILE_MAX_SIZE")  # 10MB
+    log_file_backup_count: int = Field(default=5, env="LOG_FILE_BACKUP_COUNT")
+    
+    # Cost & Performance Logging
+    log_cost_metrics: bool = Field(default=True, env="LOG_COST_METRICS")
+    cost_log_path: str = Field(default="logs/saap_costs.log", env="COST_LOG_PATH")
+    performance_log_path: str = Field(default="logs/saap_performance.log", env="PERFORMANCE_LOG_PATH")
+
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+
+class AgentSettings(BaseSettings):
+    """Enhanced agent-specific configuration with multi-provider support"""
+    
+    default_agent_timeout: int = Field(default=60, env="DEFAULT_AGENT_TIMEOUT")
+    max_concurrent_agents: int = Field(default=10, env="MAX_CONCURRENT_AGENTS")
+    agent_health_check_interval: int = Field(default=300, env="AGENT_HEALTH_CHECK_INTERVAL")  # 5 minutes
+    
+    # Performance settings
+    max_message_history: int = Field(default=1000, env="MAX_MESSAGE_HISTORY")
+    cleanup_old_messages_days: int = Field(default=30, env="CLEANUP_OLD_MESSAGES_DAYS")
+    
+    # Multi-Provider Strategy
+    primary_provider: str = Field(default="colossus", env="PRIMARY_PROVIDER")  # colossus, openrouter
+    fallback_provider: str = Field(default="openrouter", env="FALLBACK_PROVIDER")
+    auto_fallback_on_error: bool = Field(default=True, env="AUTO_FALLBACK_ON_ERROR")
+    fallback_timeout_threshold: int = Field(default=30, env="FALLBACK_TIMEOUT_THRESHOLD")  # seconds
+    
+    # Cost Efficiency Targets
+    target_response_time: float = Field(default=2.0, env="TARGET_RESPONSE_TIME")  # seconds
+    target_cost_per_request: float = Field(default=0.002, env="TARGET_COST_PER_REQUEST")  # $0.002
+    cost_vs_speed_priority: str = Field(default="balanced", env="COST_VS_SPEED_PRIORITY")  # cost, speed, balanced
+    
+    # Daily Cost Budgets
+    daily_cost_budget: float = Field(default=10.0, env="DAILY_COST_BUDGET")  # $10/day
+    agent_cost_budget: float = Field(default=2.0, env="AGENT_COST_BUDGET")  # $2/agent/day
+    warning_cost_threshold: float = Field(default=0.80, env="WARNING_COST_THRESHOLD")  # 80%
+    
+    # Model Selection Strategy
+    use_free_models_first: bool = Field(default=False, env="USE_FREE_MODELS_FIRST")
+    smart_model_selection: bool = Field(default=True, env="SMART_MODEL_SELECTION")
+    cost_learning_enabled: bool = Field(default=True, env="COST_LEARNING_ENABLED")
+
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields
+    }
+    
+    @field_validator('primary_provider', 'fallback_provider')
+    def validate_provider(cls, v):
+        """Validate provider names"""
+        allowed = ['colossus', 'openrouter']
+        if v not in allowed:
+            raise ValueError(f'Provider must be one of: {allowed}')
+        return v
+        
+    @field_validator('cost_vs_speed_priority')  
+    def validate_priority(cls, v):
+        """Validate priority setting"""
+        allowed = ['cost', 'speed', 'balanced']
+        if v not in allowed:
+            raise ValueError(f'Priority must be one of: {allowed}')
+        return v
+
+class SaapSettings(BaseSettings):
+    """Main SAAP Application Settings with OpenRouter Integration"""
+    
+    # Application Info
+    app_name: str = Field(default="SAAP - satware AI Autonomous Agent Platform", env="APP_NAME")
+    app_version: str = Field(default="1.0.0", env="APP_VERSION")
+    environment: str = Field(default="production", env="ENVIRONMENT")
+    debug: bool = Field(default=False, env="DEBUG")
+    
+    # Server settings - Updated for network access
+    host: str = Field(default="100.64.0.45", env="HOST")  # 🌐 Changed from 0.0.0.0
+    port: int = Field(default=8000, env="PORT")
+    reload: bool = Field(default=False, env="RELOAD")
+    
+    # Component Settings
+    database: DatabaseSettings = DatabaseSettings()
+    colossus: ColossusSettings = ColossusSettings()
+    openrouter: OpenRouterSettings = OpenRouterSettings()  # NEW!
+    redis: RedisSettings = RedisSettings()
+    security: SecuritySettings = SecuritySettings()
+    logging: LoggingSettings = LoggingSettings()
+    agents: AgentSettings = AgentSettings()
+    
+    model_config = {
+        "env_file": ".env",
+        "env_file_encoding": "utf-8",
+        "case_sensitive": False,
+        "extra": "allow"  # Allow extra fields from .env that aren't explicitly defined
+    }
+        
+    @field_validator('environment')
+    def validate_environment(cls, v):
+        """Validate environment setting"""
+        allowed_envs = ['development', 'staging', 'production', 'testing']
+        if v.lower() not in allowed_envs:
+            raise ValueError(f'Environment must be one of: {allowed_envs}')
+        return v.lower()
+    
+    def get_database_url(self) -> str:
+        """Get database URL with environment-specific adjustments"""
+        if self.environment == 'testing':
+            return "sqlite:///./test_saap.db"
+        elif self.environment == 'development':
+            return "sqlite:///./saap_dev.db"
+        else:
+            return self.database.database_url
+    
+    def is_production(self) -> bool:
+        """Check if running in production"""
+        return self.environment == 'production'
+    
+    def get_cors_origins(self) -> List[str]:
+        """Get CORS allowed origins as list"""
+        return self.security.get_allowed_origins_list()
+    
+    def get_log_config(self) -> dict:
+        """Get logging configuration for uvicorn/fastapi"""
+        return {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "default": {
+                    "format": self.logging.log_format,
+                },
+                "cost": {
+                    "format": "%(asctime)s - COST - %(message)s",
+                },
+                "performance": {
+                    "format": "%(asctime)s - PERF - %(message)s",
+                }
+            },
+            "handlers": {
+                "default": {
+                    "formatter": "default",
+                    "class": "logging.StreamHandler",
+                    "stream": "ext://sys.stdout",
+                },
+                "file": {
+                    "formatter": "default",
+                    "class": "logging.handlers.RotatingFileHandler",
+                    "filename": self.logging.log_file_path,
+                    "maxBytes": self.logging.log_file_max_size,
+                    "backupCount": self.logging.log_file_backup_count,
+                } if self.logging.log_to_file else None,
+                "cost_file": {
+                    "formatter": "cost", 
+                    "class": "logging.handlers.RotatingFileHandler",
+                    "filename": self.logging.cost_log_path,
+                    "maxBytes": self.logging.log_file_max_size,
+                    "backupCount": self.logging.log_file_backup_count,
+                } if self.logging.log_cost_metrics else None,
+                "performance_file": {
+                    "formatter": "performance",
+                    "class": "logging.handlers.RotatingFileHandler", 
+                    "filename": self.logging.performance_log_path,
+                    "maxBytes": self.logging.log_file_max_size,
+                    "backupCount": self.logging.log_file_backup_count,
+                } if self.logging.log_cost_metrics else None
+            },
+            "loggers": {
+                "": {
+                    "handlers": [h for h in ["default", "file"] if h],
+                    "level": self.logging.log_level,
+                },
+                "saap.cost": {
+                    "handlers": [h for h in ["cost_file"] if h],
+                    "level": "INFO",
+                    "propagate": False,
+                },
+                "saap.performance": {
+                    "handlers": [h for h in ["performance_file"] if h], 
+                    "level": "INFO",
+                    "propagate": False,
+                }
+            },
+        }
+        
+    def get_openrouter_config_for_agent(self, agent_name: str) -> dict:
+        """Get OpenRouter configuration for specific agent"""
+        return self.openrouter.get_agent_model_config(agent_name)
+
+@lru_cache()
+def get_settings() -> SaapSettings:
+    """Get cached settings instance"""
+    return SaapSettings()
+
+# Global settings instance
+settings = get_settings()
+
+# Create logs directory if needed
+if settings.logging.log_to_file:
+    Path(settings.logging.log_file_path).parent.mkdir(parents=True, exist_ok=True)
+if settings.logging.log_cost_metrics:
+    Path(settings.logging.cost_log_path).parent.mkdir(parents=True, exist_ok=True)
+    Path(settings.logging.performance_log_path).parent.mkdir(parents=True, exist_ok=True)
+
+# Environment-specific logging setup
+def setup_logging():
+    """Setup logging configuration"""
+    import logging.config
+    
+    log_config = settings.get_log_config()
+    logging.config.dictConfig(log_config)
+    
+    logger = logging.getLogger(__name__)
+    
+    logger.info(f"🚀 SAAP Configuration loaded:")
+    logger.info(f"   Environment: {settings.environment}")
+    logger.info(f"   Database: {settings.get_database_url()}")
+    logger.info(f"   colossus: {settings.colossus.api_base}")
+    logger.info(f"   OpenRouter: {settings.openrouter.enabled}")
+    logger.info(f"   Redis: {settings.redis.host}:{settings.redis.port}")
+    logger.info(f"   Debug Mode: {settings.debug}")
+    logger.info(f"🌐 Server Host: {settings.host}:{settings.port}")  # Log the network settings
+    logger.info(f"🔒 CORS Origins: {settings.get_cors_origins()}")
+    
+    # Cost tracking logger
+    if settings.logging.log_cost_metrics:
+        cost_logger = logging.getLogger("saap.cost")
+        cost_logger.info("💰 Cost tracking initialized")
+        
+        performance_logger = logging.getLogger("saap.performance")
+        performance_logger.info("📊 Performance monitoring initialized")
+
+if __name__ == "__main__":
+    # Test configuration
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    
+    logger.info("🧪 Configuration Test:")
+    logger.info(f"   App Name: {settings.app_name}")
+    logger.info(f"   Database URL: {settings.get_database_url()}")
+    logger.info(f"   Production Mode: {settings.is_production()}")
+    logger.info(f"   OpenRouter Enabled: {settings.openrouter.enabled}")
+    logger.info(f"🌐 Network Settings:")
+    logger.info(f"   Host: {settings.host}")
+    logger.info(f"   Port: {settings.port}")
+    logger.info(f"   CORS Origins: {settings.get_cors_origins()}")
+    
+    # Test agent model configs
+    for agent in ['jane_alesi', 'john_alesi', 'lara_alesi']:
+        config = settings.get_openrouter_config_for_agent(agent)
+        logger.info(f"   {agent}: {config['model']} (${config['cost_per_1m']}/1M tokens)")

backend/test_colossus_integration.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+SAAP colossus Server Integration Test Script
+Quick-Test für colossus Server Integration und Performance-Benchmark
+
+Usage:
+python test_colossus_integration.py
+
+Author: Hanan Wandji Danga
+"""
+
+import asyncio
+import sys
+import os
+import json
+import time
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Add parent directory to path for imports
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from agents.colossus_saap_agent import ColossusSAAPAgent, ColossusBenchmark, create_saap_colossus_agents
+
+# colossus Server Configuration
+API_KEY = os.getenv("COLOSSUS_API_KEY", "")
+BASE_URL = "https://ai.adrian-schupp.de"
+MODEL_NAME = "mistral-small3.2:24b-instruct-2506"
+
+async def test_colossus_connection():
+    """
+    Test 1: Grundlegende Konnektivität und API-Funktionalität
+    """
+    print("🔗 TEST 1: colossus Server Connection Test")
+    print("=" * 50)
+    
+    agent = ColossusSAAPAgent("test_coordinator", "Coordinator", API_KEY, BASE_URL)
+    
+    # Health Check
+    print("📊 Running health check...")
+    health = await agent.health_check()
+    
+    print(f"Status: {health['colossus_status']}")
+    print(f"Response Time: {health.get('response_time', 'N/A')}s")
+    
+    if health.get('error'):
+        print(f"❌ Error: {health['error']}")
+        return False
+    
+    print("✅ colossus Server is healthy and reachable")
+    return True
+
+async def test_saap_agent_roles():
+    """
+    Test 2: SAAP Agent Rollen-spezifische Responses
+    """
+    print("\n🤖 TEST 2: SAAP Agent Role-Specific Responses")
+    print("=" * 50)
+    
+    # Erstelle die 3 Basis-Agenten aus dem Plan
+    agents = create_saap_colossus_agents(API_KEY)
+    
+    test_questions = [
+        {
+            "agent": "agent_coordinator",
+            "role": "Coordinator", 
+            "question": "Wie koordinierst du mehrere Agenten in einem SAAP-System?"
+        },
+        {
+            "agent": "agent_developer", 
+            "role": "Developer",
+            "question": "Welche Python-Bibliotheken empfiehlst du für Multi-Agent-Systeme?"
+        },
+        {
+            "agent": "agent_analyst",
+            "role": "Analyst", 
+            "question": "Analysiere die Performance-Vorteile von On-Premise vs Cloud AI."
+        }
+    ]
+    
+    for test in test_questions:
+        print(f"\n👤 Testing {test['role']} Agent...")
+        
+        # Find entsprechenden Agent
+        agent = next((a for a in agents if a.agent_name == test['agent']), None)
+        if not agent:
+            print(f"❌ Agent {test['agent']} not found")
+            continue
+        
+        # Sende Anfrage
+        result = await agent.send_request_to_colossus(test['question'])
+        
+        if result['success']:
+            print(f"✅ Response Time: {result['response_time']}s")
+            print(f"📝 Response: {result['response'][:200]}...")
+            print(f"🔢 Tokens: {result['token_count']}")
+        else:
+            print(f"❌ Failed: {result.get('error')}")
+
+async def test_performance_benchmark():
+    """
+    Test 3: Performance Benchmark für < 2s Response-Zeit Ziel
+    """
+    print("\n⚡ TEST 3: Performance Benchmark (Target: < 2s)")
+    print("=" * 50)
+    
+    benchmark = ColossusBenchmark(API_KEY)
+    
+    # SAAP-spezifische Test-Prompts
+    test_prompts = [
+        "Was ist SAAP?",
+        "Erkläre Multi-Agent Systeme kurz.",
+        "Vorteile von On-Premise AI?", 
+        "Wie funktioniert Agent-Koordination?",
+        "Python für AI-Entwicklung?"
+    ]
+    
+    print(f"🧪 Running {len(test_prompts)} performance tests...")
+    results = await benchmark.run_performance_benchmark(test_prompts)
+    
+    print(f"\n📊 BENCHMARK RESULTS:")
+    print(f"Total Tests: {results['total_tests']}")
+    print(f"Successful Tests: {results['successful_tests']}")
+    print(f"Success Rate: {results['success_rate']:.1f}%")
+    
+    if results.get('average_response_time'):
+        print(f"Average Response Time: {results['average_response_time']}s")
+        print(f"Average Token Count: {results['average_token_count']}")
+        
+        # Performance Target Check
+        target_met = results['performance_target_met']
+        target_symbol = "✅" if target_met else "❌"
+        print(f"{target_symbol} Performance Target (< 2s): {'MET' if target_met else 'NOT MET'}")
+        
+        if not target_met:
+            print("💡 Optimization suggestions will be provided for performance improvement")
+    else:
+        print("❌ No successful tests - check connection and API key")
+    
+    return results
+
+async def test_multi_agent_communication():
+    """
+    Test 4: Multi-Agent Kommunikation via Redis
+    """
+    print("\n💬 TEST 4: Multi-Agent Communication Test") 
+    print("=" * 50)
+    
+    try:
+        import redis
+        redis_client = redis.Redis(host='localhost', port=6379, decode_responses=True)
+        
+        # Test Redis connection
+        redis_client.ping()
+        print("✅ Redis connection successful")
+        
+        # Erstelle 2 Test-Agenten
+        coordinator = ColossusSAAPAgent("test_coordinator", "Coordinator", API_KEY)
+        developer = ColossusSAAPAgent("test_developer", "Developer", API_KEY)
+        
+        # Sende Nachricht von Coordinator zu Developer
+        test_message = "Entwickle ein Python-Script für Agent-Kommunikation"
+        print(f"📤 Coordinator → Developer: {test_message}")
+        
+        coordinator.send_message_to_agent("test_developer", test_message)
+        
+        # Simuliere Developer Response
+        print("🔄 Developer processing message...")
+        await asyncio.sleep(1)
+        
+        # Check Redis queue
+        queue_length = redis_client.llen("saap_agent_test_developer")
+        print(f"📊 Developer message queue length: {queue_length}")
+        
+        if queue_length > 0:
+            print("✅ Multi-Agent communication working")
+        else:
+            print("⚠️ No messages in queue - check Redis setup")
+            
+    except ImportError:
+        print("❌ Redis not available - install with: pip install redis")
+    except Exception as e:
+        print(f"❌ Redis connection failed: {e}")
+        print("💡 Make sure Redis/Valkey is running: systemctl start valkey")
+
+def print_next_steps(performance_results):
+    """
+    Druckt Next Steps basierend auf Test-Ergebnissen
+    """
+    print("\n🎯 NEXT STEPS - Week 1-2 Infrastructure Foundation")
+    print("=" * 60)
+    
+    if performance_results and performance_results.get('success_rate', 0) > 80:
+        print("✅ colossus Integration erfolgreich!")
+        print("🚀 Ready für Phase 1 Implementation:")
+        print("   1. Integriere colossus Agents in bestehendes SAAP-System")
+        print("   2. Update Vue.js Dashboard für colossus Agent-Monitoring")
+        print("   3. Teste 3 Basis-Agenten (Coordinator, Developer, Analyst)")
+        print("   4. OpenRouter GLM 4.5 Air als Fallback konfigurieren")
+        print("   5. Performance-Optimierung wenn Response-Zeit > 2s")
+        
+        print(f"\n📊 Performance Status:")
+        avg_time = performance_results.get('average_response_time', 0)
+        if avg_time < 2.0:
+            print(f"   ✅ Target erfüllt: {avg_time}s < 2s")
+        else:
+            print(f"   ⚠️ Optimierung nötig: {avg_time}s > 2s")
+            print("   💡 Optimierungen: Model-Caching, Connection-Pooling, Prompt-Optimization")
+    else:
+        print("❌ colossus Integration needs fixes:")
+        print("   1. Check API Key and URL")
+        print("   2. Verify network connectivity") 
+        print("   3. Test model availability")
+        print("   4. Check server status")
+
+async def main():
+    """
+    Hauptfunktion - führt alle Tests sequentiell durch
+    """
+    print("🚀 SAAP colossus Server Integration Tests")
+    print("=" * 60)
+    print(f"Target: {BASE_URL}")
+    print(f"Model: {MODEL_NAME}")
+    print(f"Performance Goal: < 2s response time")
+    print("")
+    
+    # Validate API key
+    if not API_KEY:
+        print("❌ Error: COLOSSUS_API_KEY environment variable not set")
+        print("Please add COLOSSUS_API_KEY to backend/.env file")
+        return
+    
+    # Test 1: Basic Connectivity
+    connection_ok = await test_colossus_connection()
+    
+    if not connection_ok:
+        print("\n❌ Basic connection failed. Check server and API key.")
+        return
+    
+    # Test 2: Role-specific responses
+    await test_saap_agent_roles()
+    
+    # Test 3: Performance benchmark
+    performance_results = await test_performance_benchmark()
+    
+    # Test 4: Multi-Agent communication  
+    await test_multi_agent_communication()
+    
+    # Summary and next steps
+    print_next_steps(performance_results)
+    
+    print(f"\n🎓 Integration Status: Ready for SAAP Phase 1 Development")
+    print("📚 Master Thesis Progress: Infrastructure Foundation Complete")
+
+if __name__ == "__main__":
+    # Run all tests
+    asyncio.run(main())

backend/websocket_manager.py

@@ -0,0 +1,361 @@
+"""
+SAAP WebSocket Manager Service - Real-time Communication
+Production-ready WebSocket connection management for live agent updates
+"""
+
+import asyncio
+import json
+import logging
+from typing import Set, Dict, Any, Optional
+from datetime import datetime
+
+from fastapi import WebSocket, WebSocketDisconnect
+from models.agent import SaapAgent
+
+logger = logging.getLogger(__name__)
+
+class WebSocketConnection:
+    """Individual WebSocket connection wrapper"""
+    
+    def __init__(self, websocket: WebSocket, client_id: Optional[str] = None):
+        self.websocket = websocket
+        self.client_id = client_id or f"client_{id(websocket)}"
+        self.connected_at = datetime.utcnow()
+        self.is_alive = True
+        
+    async def send_message(self, message: Dict[str, Any]):
+        """Send message to this WebSocket connection"""
+        try:
+            if self.is_alive:
+                await self.websocket.send_text(json.dumps(message))
+        except Exception as e:
+            logger.warning(f"⚠️ Failed to send to {self.client_id}: {e}")
+            self.is_alive = False
+    
+    async def send_ping(self):
+        """Send ping to keep connection alive"""
+        try:
+            if self.is_alive:
+                await self.websocket.send_text(json.dumps({
+                    "type": "ping",
+                    "timestamp": datetime.utcnow().isoformat()
+                }))
+        except Exception:
+            self.is_alive = False
+
+class WebSocketManager:
+    """
+    Production-ready WebSocket Manager
+    Features:
+    - Multi-client connection management
+    - Real-time agent status broadcasts
+    - Message history and statistics
+    - Connection health monitoring
+    - Automatic cleanup of dead connections
+    """
+    
+    def __init__(self):
+        self.active_connections: Set[WebSocketConnection] = set()
+        self.client_connections: Dict[str, WebSocketConnection] = {}
+        self.message_history: List[Dict[str, Any]] = []
+        self.max_history_size = 100
+        self.stats = {
+            "total_connections": 0,
+            "current_connections": 0,
+            "messages_sent": 0,
+            "broadcasts_sent": 0
+        }
+        
+        # Start periodic cleanup task
+        self._cleanup_task = None
+        
+    async def start_cleanup_task(self):
+        """Start periodic cleanup of dead connections"""
+        if not self._cleanup_task:
+            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
+    
+    async def _periodic_cleanup(self):
+        """Periodically clean up dead connections"""
+        try:
+            while True:
+                await asyncio.sleep(30)  # Check every 30 seconds
+                await self._cleanup_dead_connections()
+        except asyncio.CancelledError:
+            logger.info("🔧 WebSocket cleanup task cancelled")
+    
+    async def _cleanup_dead_connections(self):
+        """Remove dead/closed WebSocket connections"""
+        dead_connections = set()
+        
+        for connection in self.active_connections:
+            if not connection.is_alive:
+                dead_connections.add(connection)
+                continue
+                
+            # Try to ping the connection
+            try:
+                await connection.send_ping()
+            except Exception:
+                connection.is_alive = False
+                dead_connections.add(connection)
+        
+        # Remove dead connections
+        for connection in dead_connections:
+            self.disconnect(connection.websocket, log=False)
+        
+        if dead_connections:
+            logger.info(f"🧹 Cleaned up {len(dead_connections)} dead WebSocket connections")
+    
+    async def connect(self, websocket: WebSocket, client_id: Optional[str] = None):
+        """Accept new WebSocket connection"""
+        try:
+            await websocket.accept()
+            
+            connection = WebSocketConnection(websocket, client_id)
+            self.active_connections.add(connection)
+            self.client_connections[connection.client_id] = connection
+            
+            # Update statistics
+            self.stats["total_connections"] += 1
+            self.stats["current_connections"] = len(self.active_connections)
+            
+            logger.info(f"✅ WebSocket connected: {connection.client_id} (Total: {len(self.active_connections)})\"")
+            
+            # Send welcome message with connection info
+            await connection.send_message({
+                "type": "connection_established",
+                "client_id": connection.client_id,
+                "server_time": datetime.utcnow().isoformat(),
+                "message": "Connected to SAAP WebSocket server"
+            })
+            
+            # Send current stats
+            await connection.send_message({
+                "type": "stats_update",
+                "data": await self.get_connection_stats()
+            })
+            
+            # Start cleanup task if not already running
+            await self.start_cleanup_task()
+            
+        except Exception as e:
+            logger.error(f"❌ WebSocket connection failed: {e}")
+    
+    def disconnect(self, websocket: WebSocket, log: bool = True):
+        """Remove WebSocket connection"""
+        connection_to_remove = None
+        
+        for connection in self.active_connections:
+            if connection.websocket == websocket:
+                connection_to_remove = connection
+                break
+        
+        if connection_to_remove:
+            self.active_connections.discard(connection_to_remove)
+            self.client_connections.pop(connection_to_remove.client_id, None)
+            connection_to_remove.is_alive = False
+            
+            self.stats["current_connections"] = len(self.active_connections)
+            
+            if log:
+                logger.info(f"🔌 WebSocket disconnected: {connection_to_remove.client_id} (Remaining: {len(self.active_connections)})")
+    
+    async def broadcast_message(self, message: Dict[str, Any]):
+        """Broadcast message to all connected clients"""
+        if not self.active_connections:
+            return
+        
+        try:
+            # Add timestamp and message type
+            broadcast_message = {
+                **message,
+                "timestamp": datetime.utcnow().isoformat(),
+                "broadcast": True
+            }
+            
+            # Send to all connections
+            dead_connections = set()
+            successful_sends = 0
+            
+            for connection in self.active_connections:
+                try:
+                    await connection.send_message(broadcast_message)
+                    successful_sends += 1
+                except Exception as e:
+                    logger.warning(f"⚠️ Broadcast failed for {connection.client_id}: {e}")
+                    dead_connections.add(connection)
+            
+            # Remove dead connections
+            for connection in dead_connections:
+                self.disconnect(connection.websocket, log=False)
+            
+            # Update statistics
+            self.stats["messages_sent"] += successful_sends
+            self.stats["broadcasts_sent"] += 1
+            
+            # Add to message history
+            self._add_to_history(broadcast_message)
+            
+            logger.debug(f"📢 Broadcast sent to {successful_sends} clients: {message.get('type', 'unknown')}")
+            
+        except Exception as e:
+            logger.error(f"❌ Broadcast failed: {e}")
+    
+    async def send_to_client(self, client_id: str, message: Dict[str, Any]):
+        """Send message to specific client"""
+        connection = self.client_connections.get(client_id)
+        if not connection:
+            logger.warning(f"⚠️ Client not found: {client_id}")
+            return False
+        
+        try:
+            message_with_timestamp = {
+                **message,
+                "timestamp": datetime.utcnow().isoformat(),
+                "targeted": True,
+                "client_id": client_id
+            }
+            
+            await connection.send_message(message_with_timestamp)
+            self.stats["messages_sent"] += 1
+            
+            logger.debug(f"📤 Message sent to {client_id}: {message.get('type', 'unknown')}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to send to {client_id}: {e}")
+            self.disconnect(connection.websocket)
+            return False
+    
+    def _add_to_history(self, message: Dict[str, Any]):
+        """Add message to broadcast history"""
+        self.message_history.append(message)
+        
+        # Trim history if too long
+        if len(self.message_history) > self.max_history_size:
+            self.message_history = self.message_history[-self.max_history_size:]
+    
+    async def get_connection_stats(self) -> Dict[str, Any]:
+        """Get WebSocket connection statistics"""
+        return {
+            **self.stats,
+            "current_connections": len(self.active_connections),
+            "client_ids": [conn.client_id for conn in self.active_connections],
+            "message_history_size": len(self.message_history),
+            "server_time": datetime.utcnow().isoformat()
+        }
+    
+    # SAAP-specific broadcast methods
+    
+    async def broadcast_agent_update(self, agent: SaapAgent):
+        """Broadcast agent status update to all clients"""
+        # Handle both Enum and string status/type values
+        status_value = agent.status.value if hasattr(agent.status, 'value') else str(agent.status)
+        type_value = agent.type.value if hasattr(agent.type, 'value') else str(agent.type)
+        
+        # Handle optional metrics attribute
+        last_active = None
+        if hasattr(agent, 'metrics') and agent.metrics:
+            if hasattr(agent.metrics, 'last_active') and agent.metrics.last_active:
+                last_active = agent.metrics.last_active.isoformat()
+        
+        await self.broadcast_message({
+            "type": "agent_update",
+            "data": {
+                "agent_id": agent.id,
+                "name": agent.name,
+                "status": status_value,
+                "type": type_value,
+                "last_active": last_active,
+                "capabilities": agent.capabilities
+            }
+        })
+    
+    async def broadcast_agent_deleted(self, agent_id: str):
+        """Broadcast agent deletion to all clients"""
+        await self.broadcast_message({
+            "type": "agent_deleted",
+            "data": {
+                "agent_id": agent_id
+            }
+        })
+    
+    async def broadcast_message_update(self, message_data: Dict[str, Any]):
+        """Broadcast new agent message/response to all clients"""
+        await self.broadcast_message({
+            "type": "agent_message",
+            "data": message_data
+        })
+    
+    async def broadcast_system_status(self, status_data: Dict[str, Any]):
+        """Broadcast system status update"""
+        await self.broadcast_message({
+            "type": "system_status",
+            "data": status_data
+        })
+    
+    async def broadcast_error(self, error_message: str, error_code: Optional[str] = None):
+        """Broadcast system error to all clients"""
+        await self.broadcast_message({
+            "type": "system_error",
+            "data": {
+                "message": error_message,
+                "code": error_code,
+                "severity": "error"
+            }
+        })
+    
+    async def shutdown(self):
+        """Gracefully shutdown WebSocket manager"""
+        try:
+            logger.info("🔧 Shutting down WebSocket manager...")
+            
+            # Cancel cleanup task
+            if self._cleanup_task:
+                self._cleanup_task.cancel()
+                try:
+                    await self._cleanup_task
+                except asyncio.CancelledError:
+                    pass
+            
+            # Send shutdown notification to all clients
+            await self.broadcast_message({
+                "type": "server_shutdown",
+                "data": {
+                    "message": "SAAP server is shutting down",
+                    "timestamp": datetime.utcnow().isoformat()
+                }
+            })
+            
+            # Close all connections
+            for connection in list(self.active_connections):
+                try:
+                    await connection.websocket.close()
+                except Exception:
+                    pass
+                self.disconnect(connection.websocket, log=False)
+            
+            logger.info("✅ WebSocket manager shutdown complete")
+            
+        except Exception as e:
+            logger.error(f"❌ WebSocket shutdown error: {e}")
+
+if __name__ == "__main__":
+    async def test_websocket_manager():
+        """Test WebSocket manager functionality"""
+        manager = WebSocketManager()
+        
+        # Simulate stats
+        print("📊 WebSocket Manager Stats:")
+        stats = await manager.get_connection_stats()
+        print(json.dumps(stats, indent=2))
+        
+        # Test broadcast (no clients, but should not error)
+        await manager.broadcast_message({
+            "type": "test",
+            "message": "Test broadcast"
+        })
+        
+        print("✅ WebSocket manager test completed")
+    
+    asyncio.run(test_websocket_manager())

frontend/dist/assets/icons-l0sNRNKZ.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=icons-l0sNRNKZ.js.map

frontend/dist/assets/icons-l0sNRNKZ.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"icons-l0sNRNKZ.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

frontend/dist/assets/vendor-Ctwcxhgt.js

@@ -1,26 +0,0 @@
-/**
-* @vue/shared v3.5.22
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/function Ls(e){const t=Object.create(null);for(const n of e.split(","))t[n]=1;return n=>n in t}const ie={},Lt=[],qe=()=>{},fo=()=>!1,kn=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),Ns=e=>e.startsWith("onUpdate:"),de=Object.assign,Fs=(e,t)=>{const n=e.indexOf(t);n>-1&&e.splice(n,1)},qi=Object.prototype.hasOwnProperty,ee=(e,t)=>qi.call(e,t),D=Array.isArray,Nt=e=>pn(e)==="[object Map]",kt=e=>pn(e)==="[object Set]",or=e=>pn(e)==="[object Date]",K=e=>typeof e=="function",ue=e=>typeof e=="string",Ge=e=>typeof e=="symbol",ne=e=>e!==null&&typeof e=="object",uo=e=>(ne(e)||K(e))&&K(e.then)&&K(e.catch),ao=Object.prototype.toString,pn=e=>ao.call(e),Gi=e=>pn(e).slice(8,-1),ho=e=>pn(e)==="[object Object]",js=e=>ue(e)&&e!=="NaN"&&e[0]!=="-"&&""+parseInt(e,10)===e,qt=Ls(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),Vn=e=>{const t=Object.create(null);return n=>t[n]||(t[n]=e(n))},zi=/-\w/g,Ne=Vn(e=>e.replace(zi,t=>t.slice(1).toUpperCase())),Ji=/\B([A-Z])/g,_t=Vn(e=>e.replace(Ji,"-$1").toLowerCase()),Bn=Vn(e=>e.charAt(0).toUpperCase()+e.slice(1)),ns=Vn(e=>e?`on${Bn(e)}`:""),pt=(e,t)=>!Object.is(e,t),wn=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},po=(e,t,n,s=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:s,value:n})},Tn=e=>{const t=parseFloat(e);return isNaN(t)?e:t},Qi=e=>{const t=ue(e)?Number(e):NaN;return isNaN(t)?e:t};let ir;const Kn=()=>ir||(ir=typeof globalThis<"u"?globalThis:typeof self<"u"?self:typeof window<"u"?window:typeof global<"u"?global:{});function Ds(e){if(D(e)){const t={};for(let n=0;n<e.length;n++){const s=e[n],r=ue(s)?el(s):Ds(s);if(r)for(const o in r)t[o]=r[o]}return t}else if(ue(e)||ne(e))return e}const Yi=/;(?![^(]*\))/g,Xi=/:([^]+)/,Zi=/\/\*[^]*?\*\//g;function el(e){const t={};return e.replace(Zi,"").split(Yi).forEach(n=>{if(n){const s=n.split(Xi);s.length>1&&(t[s[0].trim()]=s[1].trim())}}),t}function $s(e){let t="";if(ue(e))t=e;else if(D(e))for(let n=0;n<e.length;n++){const s=$s(e[n]);s&&(t+=s+" ")}else if(ne(e))for(const n in e)e[n]&&(t+=n+" ");return t.trim()}const tl="itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly",nl=Ls(tl);function go(e){return!!e||e===""}function sl(e,t){if(e.length!==t.length)return!1;let n=!0;for(let s=0;n&&s<e.length;s++)n=gn(e[s],t[s]);return n}function gn(e,t){if(e===t)return!0;let n=or(e),s=or(t);if(n||s)return n&&s?e.getTime()===t.getTime():!1;if(n=Ge(e),s=Ge(t),n||s)return e===t;if(n=D(e),s=D(t),n||s)return n&&s?sl(e,t):!1;if(n=ne(e),s=ne(t),n||s){if(!n||!s)return!1;const r=Object.keys(e).length,o=Object.keys(t).length;if(r!==o)return!1;for(const i in e){const l=e.hasOwnProperty(i),c=t.hasOwnProperty(i);if(l&&!c||!l&&c||!gn(e[i],t[i]))return!1}}return String(e)===String(t)}function Hs(e,t){return e.findIndex(n=>gn(n,t))}const mo=e=>!!(e&&e.__v_isRef===!0),rl=e=>ue(e)?e:e==null?"":D(e)||ne(e)&&(e.toString===ao||!K(e.toString))?mo(e)?rl(e.value):JSON.stringify(e,yo,2):String(e),yo=(e,t)=>mo(t)?yo(e,t.value):Nt(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((n,[s,r],o)=>(n[ss(s,o)+" =>"]=r,n),{})}:kt(t)?{[`Set(${t.size})`]:[...t.values()].map(n=>ss(n))}:Ge(t)?ss(t):ne(t)&&!D(t)&&!ho(t)?String(t):t,ss=(e,t="")=>{var n;return Ge(e)?`Symbol(${(n=e.description)!=null?n:t})`:e};/**
-* @vue/reactivity v3.5.22
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/let pe;class _o{constructor(t=!1){this.detached=t,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this.parent=pe,!t&&pe&&(this.index=(pe.scopes||(pe.scopes=[])).push(this)-1)}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let t,n;if(this.scopes)for(t=0,n=this.scopes.length;t<n;t++)this.scopes[t].pause();for(t=0,n=this.effects.length;t<n;t++)this.effects[t].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let t,n;if(this.scopes)for(t=0,n=this.scopes.length;t<n;t++)this.scopes[t].resume();for(t=0,n=this.effects.length;t<n;t++)this.effects[t].resume()}}run(t){if(this._active){const n=pe;try{return pe=this,t()}finally{pe=n}}}on(){++this._on===1&&(this.prevScope=pe,pe=this)}off(){this._on>0&&--this._on===0&&(pe=this.prevScope,this.prevScope=void 0)}stop(t){if(this._active){this._active=!1;let n,s;for(n=0,s=this.effects.length;n<s;n++)this.effects[n].stop();for(this.effects.length=0,n=0,s=this.cleanups.length;n<s;n++)this.cleanups[n]();if(this.cleanups.length=0,this.scopes){for(n=0,s=this.scopes.length;n<s;n++)this.scopes[n].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!t){const r=this.parent.scopes.pop();r&&r!==this&&(this.parent.scopes[this.index]=r,r.index=this.index)}this.parent=void 0}}}function vo(e){return new _o(e)}function bo(){return pe}function ol(e,t=!1){pe&&pe.cleanups.push(e)}let ce;const rs=new WeakSet;class So{constructor(t){this.fn=t,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,pe&&pe.active&&pe.effects.push(this)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,rs.has(this)&&(rs.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Eo(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,lr(this),wo(this);const t=ce,n=Fe;ce=this,Fe=!0;try{return this.fn()}finally{Co(this),ce=t,Fe=n,this.flags&=-3}}stop(){if(this.flags&1){for(let t=this.deps;t;t=t.nextDep)Bs(t);this.deps=this.depsTail=void 0,lr(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?rs.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){ys(this)&&this.run()}get dirty(){return ys(this)}}let xo=0,Gt,zt;function Eo(e,t=!1){if(e.flags|=8,t){e.next=zt,zt=e;return}e.next=Gt,Gt=e}function ks(){xo++}function Vs(){if(--xo>0)return;if(zt){let t=zt;for(zt=void 0;t;){const n=t.next;t.next=void 0,t.flags&=-9,t=n}}let e;for(;Gt;){let t=Gt;for(Gt=void 0;t;){const n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(s){e||(e=s)}t=n}}if(e)throw e}function wo(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function Co(e){let t,n=e.depsTail,s=n;for(;s;){const r=s.prevDep;s.version===-1?(s===n&&(n=r),Bs(s),il(s)):t=s,s.dep.activeLink=s.prevActiveLink,s.prevActiveLink=void 0,s=r}e.deps=t,e.depsTail=n}function ys(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ro(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ro(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===sn)||(e.globalVersion=sn,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!ys(e))))return;e.flags|=2;const t=e.dep,n=ce,s=Fe;ce=e,Fe=!0;try{wo(e);const r=e.fn(e._value);(t.version===0||pt(r,e._value))&&(e.flags|=128,e._value=r,t.version++)}catch(r){throw t.version++,r}finally{ce=n,Fe=s,Co(e),e.flags&=-3}}function Bs(e,t=!1){const{dep:n,prevSub:s,nextSub:r}=e;if(s&&(s.nextSub=r,e.prevSub=void 0),r&&(r.prevSub=s,e.nextSub=void 0),n.subs===e&&(n.subs=s,!s&&n.computed)){n.computed.flags&=-5;for(let o=n.computed.deps;o;o=o.nextDep)Bs(o,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function il(e){const{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}let Fe=!0;const Ao=[];function st(){Ao.push(Fe),Fe=!1}function rt(){const e=Ao.pop();Fe=e===void 0?!0:e}function lr(e){const{cleanup:t}=e;if(e.cleanup=void 0,t){const n=ce;ce=void 0;try{t()}finally{ce=n}}}let sn=0;class ll{constructor(t,n){this.sub=t,this.dep=n,this.version=n.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}}class Ks{constructor(t){this.computed=t,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(t){if(!ce||!Fe||ce===this.computed)return;let n=this.activeLink;if(n===void 0||n.sub!==ce)n=this.activeLink=new ll(ce,this),ce.deps?(n.prevDep=ce.depsTail,ce.depsTail.nextDep=n,ce.depsTail=n):ce.deps=ce.depsTail=n,Po(n);else if(n.version===-1&&(n.version=this.version,n.nextDep)){const s=n.nextDep;s.prevDep=n.prevDep,n.prevDep&&(n.prevDep.nextDep=s),n.prevDep=ce.depsTail,n.nextDep=void 0,ce.depsTail.nextDep=n,ce.depsTail=n,ce.deps===n&&(ce.deps=s)}return n}trigger(t){this.version++,sn++,this.notify(t)}notify(t){ks();try{for(let n=this.subs;n;n=n.prevSub)n.sub.notify()&&n.sub.dep.notify()}finally{Vs()}}}function Po(e){if(e.dep.sc++,e.sub.flags&4){const t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let s=t.deps;s;s=s.nextDep)Po(s)}const n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}const On=new WeakMap,Ct=Symbol(""),_s=Symbol(""),rn=Symbol("");function ge(e,t,n){if(Fe&&ce){let s=On.get(e);s||On.set(e,s=new Map);let r=s.get(n);r||(s.set(n,r=new Ks),r.map=s,r.key=n),r.track()}}function et(e,t,n,s,r,o){const i=On.get(e);if(!i){sn++;return}const l=c=>{c&&c.trigger()};if(ks(),t==="clear")i.forEach(l);else{const c=D(e),a=c&&js(n);if(c&&n==="length"){const f=Number(s);i.forEach((d,p)=>{(p==="length"||p===rn||!Ge(p)&&p>=f)&&l(d)})}else switch((n!==void 0||i.has(void 0))&&l(i.get(n)),a&&l(i.get(rn)),t){case"add":c?a&&l(i.get("length")):(l(i.get(Ct)),Nt(e)&&l(i.get(_s)));break;case"delete":c||(l(i.get(Ct)),Nt(e)&&l(i.get(_s)));break;case"set":Nt(e)&&l(i.get(Ct));break}}Vs()}function cl(e,t){const n=On.get(e);return n&&n.get(t)}function Tt(e){const t=Y(e);return t===e?t:(ge(t,"iterate",rn),Ie(e)?t:t.map(he))}function Un(e){return ge(e=Y(e),"iterate",rn),e}const fl={__proto__:null,[Symbol.iterator](){return os(this,Symbol.iterator,he)},concat(...e){return Tt(this).concat(...e.map(t=>D(t)?Tt(t):t))},entries(){return os(this,"entries",e=>(e[1]=he(e[1]),e))},every(e,t){return Je(this,"every",e,t,void 0,arguments)},filter(e,t){return Je(this,"filter",e,t,n=>n.map(he),arguments)},find(e,t){return Je(this,"find",e,t,he,arguments)},findIndex(e,t){return Je(this,"findIndex",e,t,void 0,arguments)},findLast(e,t){return Je(this,"findLast",e,t,he,arguments)},findLastIndex(e,t){return Je(this,"findLastIndex",e,t,void 0,arguments)},forEach(e,t){return Je(this,"forEach",e,t,void 0,arguments)},includes(...e){return is(this,"includes",e)},indexOf(...e){return is(this,"indexOf",e)},join(e){return Tt(this).join(e)},lastIndexOf(...e){return is(this,"lastIndexOf",e)},map(e,t){return Je(this,"map",e,t,void 0,arguments)},pop(){return Bt(this,"pop")},push(...e){return Bt(this,"push",e)},reduce(e,...t){return cr(this,"reduce",e,t)},reduceRight(e,...t){return cr(this,"reduceRight",e,t)},shift(){return Bt(this,"shift")},some(e,t){return Je(this,"some",e,t,void 0,arguments)},splice(...e){return Bt(this,"splice",e)},toReversed(){return Tt(this).toReversed()},toSorted(e){return Tt(this).toSorted(e)},toSpliced(...e){return Tt(this).toSpliced(...e)},unshift(...e){return Bt(this,"unshift",e)},values(){return os(this,"values",he)}};function os(e,t,n){const s=Un(e),r=s[t]();return s!==e&&!Ie(e)&&(r._next=r.next,r.next=()=>{const o=r._next();return o.done||(o.value=n(o.value)),o}),r}const ul=Array.prototype;function Je(e,t,n,s,r,o){const i=Un(e),l=i!==e&&!Ie(e),c=i[t];if(c!==ul[t]){const d=c.apply(e,o);return l?he(d):d}let a=n;i!==e&&(l?a=function(d,p){return n.call(this,he(d),p,e)}:n.length>2&&(a=function(d,p){return n.call(this,d,p,e)}));const f=c.call(i,a,s);return l&&r?r(f):f}function cr(e,t,n,s){const r=Un(e);let o=n;return r!==e&&(Ie(e)?n.length>3&&(o=function(i,l,c){return n.call(this,i,l,c,e)}):o=function(i,l,c){return n.call(this,i,he(l),c,e)}),r[t](o,...s)}function is(e,t,n){const s=Y(e);ge(s,"iterate",rn);const r=s[t](...n);return(r===-1||r===!1)&&qs(n[0])?(n[0]=Y(n[0]),s[t](...n)):r}function Bt(e,t,n=[]){st(),ks();const s=Y(e)[t].apply(e,n);return Vs(),rt(),s}const al=Ls("__proto__,__v_isRef,__isVue"),To=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!=="arguments"&&e!=="caller").map(e=>Symbol[e]).filter(Ge));function dl(e){Ge(e)||(e=String(e));const t=Y(this);return ge(t,"has",e),t.hasOwnProperty(e)}class Oo{constructor(t=!1,n=!1){this._isReadonly=t,this._isShallow=n}get(t,n,s){if(n==="__v_skip")return t.__v_skip;const r=this._isReadonly,o=this._isShallow;if(n==="__v_isReactive")return!r;if(n==="__v_isReadonly")return r;if(n==="__v_isShallow")return o;if(n==="__v_raw")return s===(r?o?xl:No:o?Lo:Io).get(t)||Object.getPrototypeOf(t)===Object.getPrototypeOf(s)?t:void 0;const i=D(t);if(!r){let c;if(i&&(c=fl[n]))return c;if(n==="hasOwnProperty")return dl}const l=Reflect.get(t,n,fe(t)?t:s);if((Ge(n)?To.has(n):al(n))||(r||ge(t,"get",n),o))return l;if(fe(l)){const c=i&&js(n)?l:l.value;return r&&ne(c)?bs(c):c}return ne(l)?r?bs(l):mn(l):l}}class Mo extends Oo{constructor(t=!1){super(!1,t)}set(t,n,s,r){let o=t[n];if(!this._isShallow){const c=mt(o);if(!Ie(s)&&!mt(s)&&(o=Y(o),s=Y(s)),!D(t)&&fe(o)&&!fe(s))return c||(o.value=s),!0}const i=D(t)&&js(n)?Number(n)<t.length:ee(t,n),l=Reflect.set(t,n,s,fe(t)?t:r);return t===Y(r)&&(i?pt(s,o)&&et(t,"set",n,s):et(t,"add",n,s)),l}deleteProperty(t,n){const s=ee(t,n);t[n];const r=Reflect.deleteProperty(t,n);return r&&s&&et(t,"delete",n,void 0),r}has(t,n){const s=Reflect.has(t,n);return(!Ge(n)||!To.has(n))&&ge(t,"has",n),s}ownKeys(t){return ge(t,"iterate",D(t)?"length":Ct),Reflect.ownKeys(t)}}class hl extends Oo{constructor(t=!1){super(!0,t)}set(t,n){return!0}deleteProperty(t,n){return!0}}const pl=new Mo,gl=new hl,ml=new Mo(!0);const vs=e=>e,bn=e=>Reflect.getPrototypeOf(e);function yl(e,t,n){return function(...s){const r=this.__v_raw,o=Y(r),i=Nt(o),l=e==="entries"||e===Symbol.iterator&&i,c=e==="keys"&&i,a=r[e](...s),f=n?vs:t?Mn:he;return!t&&ge(o,"iterate",c?_s:Ct),{next(){const{value:d,done:p}=a.next();return p?{value:d,done:p}:{value:l?[f(d[0]),f(d[1])]:f(d),done:p}},[Symbol.iterator](){return this}}}}function Sn(e){return function(...t){return e==="delete"?!1:e==="clear"?void 0:this}}function _l(e,t){const n={get(r){const o=this.__v_raw,i=Y(o),l=Y(r);e||(pt(r,l)&&ge(i,"get",r),ge(i,"get",l));const{has:c}=bn(i),a=t?vs:e?Mn:he;if(c.call(i,r))return a(o.get(r));if(c.call(i,l))return a(o.get(l));o!==i&&o.get(r)},get size(){const r=this.__v_raw;return!e&&ge(Y(r),"iterate",Ct),r.size},has(r){const o=this.__v_raw,i=Y(o),l=Y(r);return e||(pt(r,l)&&ge(i,"has",r),ge(i,"has",l)),r===l?o.has(r):o.has(r)||o.has(l)},forEach(r,o){const i=this,l=i.__v_raw,c=Y(l),a=t?vs:e?Mn:he;return!e&&ge(c,"iterate",Ct),l.forEach((f,d)=>r.call(o,a(f),a(d),i))}};return de(n,e?{add:Sn("add"),set:Sn("set"),delete:Sn("delete"),clear:Sn("clear")}:{add(r){!t&&!Ie(r)&&!mt(r)&&(r=Y(r));const o=Y(this);return bn(o).has.call(o,r)||(o.add(r),et(o,"add",r,r)),this},set(r,o){!t&&!Ie(o)&&!mt(o)&&(o=Y(o));const i=Y(this),{has:l,get:c}=bn(i);let a=l.call(i,r);a||(r=Y(r),a=l.call(i,r));const f=c.call(i,r);return i.set(r,o),a?pt(o,f)&&et(i,"set",r,o):et(i,"add",r,o),this},delete(r){const o=Y(this),{has:i,get:l}=bn(o);let c=i.call(o,r);c||(r=Y(r),c=i.call(o,r)),l&&l.call(o,r);const a=o.delete(r);return c&&et(o,"delete",r,void 0),a},clear(){const r=Y(this),o=r.size!==0,i=r.clear();return o&&et(r,"clear",void 0,void 0),i}}),["keys","values","entries",Symbol.iterator].forEach(r=>{n[r]=yl(r,e,t)}),n}function Us(e,t){const n=_l(e,t);return(s,r,o)=>r==="__v_isReactive"?!e:r==="__v_isReadonly"?e:r==="__v_raw"?s:Reflect.get(ee(n,r)&&r in s?n:s,r,o)}const vl={get:Us(!1,!1)},bl={get:Us(!1,!0)},Sl={get:Us(!0,!1)};const Io=new WeakMap,Lo=new WeakMap,No=new WeakMap,xl=new WeakMap;function El(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}function wl(e){return e.__v_skip||!Object.isExtensible(e)?0:El(Gi(e))}function mn(e){return mt(e)?e:Ws(e,!1,pl,vl,Io)}function Fo(e){return Ws(e,!1,ml,bl,Lo)}function bs(e){return Ws(e,!0,gl,Sl,No)}function Ws(e,t,n,s,r){if(!ne(e)||e.__v_raw&&!(t&&e.__v_isReactive))return e;const o=wl(e);if(o===0)return e;const i=r.get(e);if(i)return i;const l=new Proxy(e,o===2?s:n);return r.set(e,l),l}function gt(e){return mt(e)?gt(e.__v_raw):!!(e&&e.__v_isReactive)}function mt(e){return!!(e&&e.__v_isReadonly)}function Ie(e){return!!(e&&e.__v_isShallow)}function qs(e){return e?!!e.__v_raw:!1}function Y(e){const t=e&&e.__v_raw;return t?Y(t):e}function Gs(e){return!ee(e,"__v_skip")&&Object.isExtensible(e)&&po(e,"__v_skip",!0),e}const he=e=>ne(e)?mn(e):e,Mn=e=>ne(e)?bs(e):e;function fe(e){return e?e.__v_isRef===!0:!1}function Wn(e){return jo(e,!1)}function Cl(e){return jo(e,!0)}function jo(e,t){return fe(e)?e:new Rl(e,t)}class Rl{constructor(t,n){this.dep=new Ks,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=n?t:Y(t),this._value=n?t:he(t),this.__v_isShallow=n}get value(){return this.dep.track(),this._value}set value(t){const n=this._rawValue,s=this.__v_isShallow||Ie(t)||mt(t);t=s?t:Y(t),pt(t,n)&&(this._rawValue=t,this._value=s?t:he(t),this.dep.trigger())}}function Ft(e){return fe(e)?e.value:e}const Al={get:(e,t,n)=>t==="__v_raw"?e:Ft(Reflect.get(e,t,n)),set:(e,t,n,s)=>{const r=e[t];return fe(r)&&!fe(n)?(r.value=n,!0):Reflect.set(e,t,n,s)}};function Do(e){return gt(e)?e:new Proxy(e,Al)}function Pl(e){const t=D(e)?new Array(e.length):{};for(const n in e)t[n]=$o(e,n);return t}class Tl{constructor(t,n,s){this._object=t,this._key=n,this._defaultValue=s,this.__v_isRef=!0,this._value=void 0}get value(){const t=this._object[this._key];return this._value=t===void 0?this._defaultValue:t}set value(t){this._object[this._key]=t}get dep(){return cl(Y(this._object),this._key)}}class Ol{constructor(t){this._getter=t,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}}function Mu(e,t,n){return fe(e)?e:K(e)?new Ol(e):ne(e)&&arguments.length>1?$o(e,t,n):Wn(e)}function $o(e,t,n){const s=e[t];return fe(s)?s:new Tl(e,t,n)}class Ml{constructor(t,n,s){this.fn=t,this.setter=n,this._value=void 0,this.dep=new Ks(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=sn-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!n,this.isSSR=s}notify(){if(this.flags|=16,!(this.flags&8)&&ce!==this)return Eo(this,!0),!0}get value(){const t=this.dep.track();return Ro(this),t&&(t.version=this.dep.version),this._value}set value(t){this.setter&&this.setter(t)}}function Il(e,t,n=!1){let s,r;return K(e)?s=e:(s=e.get,r=e.set),new Ml(s,r,n)}const xn={},In=new WeakMap;let Et;function Ll(e,t=!1,n=Et){if(n){let s=In.get(n);s||In.set(n,s=[]),s.push(e)}}function Nl(e,t,n=ie){const{immediate:s,deep:r,once:o,scheduler:i,augmentJob:l,call:c}=n,a=L=>r?L:Ie(L)||r===!1||r===0?tt(L,1):tt(L);let f,d,p,m,x=!1,A=!1;if(fe(e)?(d=()=>e.value,x=Ie(e)):gt(e)?(d=()=>a(e),x=!0):D(e)?(A=!0,x=e.some(L=>gt(L)||Ie(L)),d=()=>e.map(L=>{if(fe(L))return L.value;if(gt(L))return a(L);if(K(L))return c?c(L,2):L()})):K(e)?t?d=c?()=>c(e,2):e:d=()=>{if(p){st();try{p()}finally{rt()}}const L=Et;Et=f;try{return c?c(e,3,[m]):e(m)}finally{Et=L}}:d=qe,t&&r){const L=d,V=r===!0?1/0:r;d=()=>tt(L(),V)}const k=bo(),N=()=>{f.stop(),k&&k.active&&Fs(k.effects,f)};if(o&&t){const L=t;t=(...V)=>{L(...V),N()}}let I=A?new Array(e.length).fill(xn):xn;const F=L=>{if(!(!(f.flags&1)||!f.dirty&&!L))if(t){const V=f.run();if(r||x||(A?V.some((se,G)=>pt(se,I[G])):pt(V,I))){p&&p();const se=Et;Et=f;try{const G=[V,I===xn?void 0:A&&I[0]===xn?[]:I,m];I=V,c?c(t,3,G):t(...G)}finally{Et=se}}}else f.run()};return l&&l(F),f=new So(d),f.scheduler=i?()=>i(F,!1):F,m=L=>Ll(L,!1,f),p=f.onStop=()=>{const L=In.get(f);if(L){if(c)c(L,4);else for(const V of L)V();In.delete(f)}},t?s?F(!0):I=f.run():i?i(F.bind(null,!0),!0):f.run(),N.pause=f.pause.bind(f),N.resume=f.resume.bind(f),N.stop=N,N}function tt(e,t=1/0,n){if(t<=0||!ne(e)||e.__v_skip||(n=n||new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,fe(e))tt(e.value,t,n);else if(D(e))for(let s=0;s<e.length;s++)tt(e[s],t,n);else if(kt(e)||Nt(e))e.forEach(s=>{tt(s,t,n)});else if(ho(e)){for(const s in e)tt(e[s],t,n);for(const s of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,s)&&tt(e[s],t,n)}return e}/**
-* @vue/runtime-core v3.5.22
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/function yn(e,t,n,s){try{return s?e(...s):e()}catch(r){qn(r,t,n)}}function je(e,t,n,s){if(K(e)){const r=yn(e,t,n,s);return r&&uo(r)&&r.catch(o=>{qn(o,t,n)}),r}if(D(e)){const r=[];for(let o=0;o<e.length;o++)r.push(je(e[o],t,n,s));return r}}function qn(e,t,n,s=!0){const r=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:i}=t&&t.appContext.config||ie;if(t){let l=t.parent;const c=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;l;){const f=l.ec;if(f){for(let d=0;d<f.length;d++)if(f[d](e,c,a)===!1)return}l=l.parent}if(o){st(),yn(o,null,10,[e,c,a]),rt();return}}Fl(e,n,r,s,i)}function Fl(e,t,n,s=!0,r=!1){if(r)throw e;console.error(e)}const ve=[];let Ke=-1;const jt=[];let ut=null,Mt=0;const Ho=Promise.resolve();let Ln=null;function Gn(e){const t=Ln||Ho;return e?t.then(this?e.bind(this):e):t}function jl(e){let t=Ke+1,n=ve.length;for(;t<n;){const s=t+n>>>1,r=ve[s],o=on(r);o<e||o===e&&r.flags&2?t=s+1:n=s}return t}function zs(e){if(!(e.flags&1)){const t=on(e),n=ve[ve.length-1];!n||!(e.flags&2)&&t>=on(n)?ve.push(e):ve.splice(jl(t),0,e),e.flags|=1,ko()}}function ko(){Ln||(Ln=Ho.then(Bo))}function Dl(e){D(e)?jt.push(...e):ut&&e.id===-1?ut.splice(Mt+1,0,e):e.flags&1||(jt.push(e),e.flags|=1),ko()}function fr(e,t,n=Ke+1){for(;n<ve.length;n++){const s=ve[n];if(s&&s.flags&2){if(e&&s.id!==e.uid)continue;ve.splice(n,1),n--,s.flags&4&&(s.flags&=-2),s(),s.flags&4||(s.flags&=-2)}}}function Vo(e){if(jt.length){const t=[...new Set(jt)].sort((n,s)=>on(n)-on(s));if(jt.length=0,ut){ut.push(...t);return}for(ut=t,Mt=0;Mt<ut.length;Mt++){const n=ut[Mt];n.flags&4&&(n.flags&=-2),n.flags&8||n(),n.flags&=-2}ut=null,Mt=0}}const on=e=>e.id==null?e.flags&2?-1:1/0:e.id;function Bo(e){try{for(Ke=0;Ke<ve.length;Ke++){const t=ve[Ke];t&&!(t.flags&8)&&(t.flags&4&&(t.flags&=-2),yn(t,t.i,t.i?15:14),t.flags&4||(t.flags&=-2))}}finally{for(;Ke<ve.length;Ke++){const t=ve[Ke];t&&(t.flags&=-2)}Ke=-1,ve.length=0,Vo(),Ln=null,(ve.length||jt.length)&&Bo()}}let Ae=null,Ko=null;function Nn(e){const t=Ae;return Ae=e,Ko=e&&e.type.__scopeId||null,t}function $l(e,t=Ae,n){if(!t||e._n)return e;const s=(...r)=>{s._d&&Dn(-1);const o=Nn(t);let i;try{i=e(...r)}finally{Nn(o),s._d&&Dn(1)}return i};return s._n=!0,s._c=!0,s._d=!0,s}function Iu(e,t){if(Ae===null)return e;const n=Xn(Ae),s=e.dirs||(e.dirs=[]);for(let r=0;r<t.length;r++){let[o,i,l,c=ie]=t[r];o&&(K(o)&&(o={mounted:o,updated:o}),o.deep&&tt(i),s.push({dir:o,instance:n,value:i,oldValue:void 0,arg:l,modifiers:c}))}return e}function vt(e,t,n,s){const r=e.dirs,o=t&&t.dirs;for(let i=0;i<r.length;i++){const l=r[i];o&&(l.oldValue=o[i].value);let c=l.dir[s];c&&(st(),je(c,n,8,[e.el,l,e,t]),rt())}}const Hl=Symbol("_vte"),Uo=e=>e.__isTeleport,Ze=Symbol("_leaveCb"),En=Symbol("_enterCb");function kl(){const e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zo(()=>{e.isMounted=!0}),ei(()=>{e.isUnmounting=!0}),e}const Oe=[Function,Array],Wo={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Oe,onEnter:Oe,onAfterEnter:Oe,onEnterCancelled:Oe,onBeforeLeave:Oe,onLeave:Oe,onAfterLeave:Oe,onLeaveCancelled:Oe,onBeforeAppear:Oe,onAppear:Oe,onAfterAppear:Oe,onAppearCancelled:Oe},qo=e=>{const t=e.subTree;return t.component?qo(t.component):t},Vl={name:"BaseTransition",props:Wo,setup(e,{slots:t}){const n=Xs(),s=kl();return()=>{const r=t.default&&Jo(t.default(),!0);if(!r||!r.length)return;const o=Go(r),i=Y(e),{mode:l}=i;if(s.isLeaving)return ls(o);const c=ur(o);if(!c)return ls(o);let a=Ss(c,i,s,n,d=>a=d);c.type!==be&&ln(c,a);let f=n.subTree&&ur(n.subTree);if(f&&f.type!==be&&!wt(f,c)&&qo(n).type!==be){let d=Ss(f,i,s,n);if(ln(f,d),l==="out-in"&&c.type!==be)return s.isLeaving=!0,d.afterLeave=()=>{s.isLeaving=!1,n.job.flags&8||n.update(),delete d.afterLeave,f=void 0},ls(o);l==="in-out"&&c.type!==be?d.delayLeave=(p,m,x)=>{const A=zo(s,f);A[String(f.key)]=f,p[Ze]=()=>{m(),p[Ze]=void 0,delete a.delayedLeave,f=void 0},a.delayedLeave=()=>{x(),delete a.delayedLeave,f=void 0}}:f=void 0}else f&&(f=void 0);return o}}};function Go(e){let t=e[0];if(e.length>1){for(const n of e)if(n.type!==be){t=n;break}}return t}const Bl=Vl;function zo(e,t){const{leavingVNodes:n}=e;let s=n.get(t.type);return s||(s=Object.create(null),n.set(t.type,s)),s}function Ss(e,t,n,s,r){const{appear:o,mode:i,persisted:l=!1,onBeforeEnter:c,onEnter:a,onAfterEnter:f,onEnterCancelled:d,onBeforeLeave:p,onLeave:m,onAfterLeave:x,onLeaveCancelled:A,onBeforeAppear:k,onAppear:N,onAfterAppear:I,onAppearCancelled:F}=t,L=String(e.key),V=zo(n,e),se=(T,U)=>{T&&je(T,s,9,U)},G=(T,U)=>{const Q=U[1];se(T,U),D(T)?T.every(P=>P.length<=1)&&Q():T.length<=1&&Q()},W={mode:i,persisted:l,beforeEnter(T){let U=c;if(!n.isMounted)if(o)U=k||c;else return;T[Ze]&&T[Ze](!0);const Q=V[L];Q&&wt(e,Q)&&Q.el[Ze]&&Q.el[Ze](),se(U,[T])},enter(T){let U=a,Q=f,P=d;if(!n.isMounted)if(o)U=N||a,Q=I||f,P=F||d;else return;let z=!1;const ae=T[En]=ye=>{z||(z=!0,ye?se(P,[T]):se(Q,[T]),W.delayedLeave&&W.delayedLeave(),T[En]=void 0)};U?G(U,[T,ae]):ae()},leave(T,U){const Q=String(e.key);if(T[En]&&T[En](!0),n.isUnmounting)return U();se(p,[T]);let P=!1;const z=T[Ze]=ae=>{P||(P=!0,U(),ae?se(A,[T]):se(x,[T]),T[Ze]=void 0,V[Q]===e&&delete V[Q])};V[Q]=e,m?G(m,[T,z]):z()},clone(T){const U=Ss(T,t,n,s,r);return r&&r(U),U}};return W}function ls(e){if(zn(e))return e=yt(e),e.children=null,e}function ur(e){if(!zn(e))return Uo(e.type)&&e.children?Go(e.children):e;if(e.component)return e.component.subTree;const{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&K(n.default))return n.default()}}function ln(e,t){e.shapeFlag&6&&e.component?(e.transition=t,ln(e.component.subTree,t)):e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function Jo(e,t=!1,n){let s=[],r=0;for(let o=0;o<e.length;o++){let i=e[o];const l=n==null?i.key:String(n)+String(i.key!=null?i.key:o);i.type===Ue?(i.patchFlag&128&&r++,s=s.concat(Jo(i.children,t,l))):(t||i.type!==be)&&s.push(l!=null?yt(i,{key:l}):i)}if(r>1)for(let o=0;o<s.length;o++)s[o].patchFlag=-2;return s}function Qo(e,t){return K(e)?de({name:e.name},t,{setup:e}):e}function Yo(e){e.ids=[e.ids[0]+e.ids[2]+++"-",0,0]}const Fn=new WeakMap;function Jt(e,t,n,s,r=!1){if(D(e)){e.forEach((x,A)=>Jt(x,t&&(D(t)?t[A]:t),n,s,r));return}if(Qt(s)&&!r){s.shapeFlag&512&&s.type.__asyncResolved&&s.component.subTree.component&&Jt(e,t,n,s.component.subTree);return}const o=s.shapeFlag&4?Xn(s.component):s.el,i=r?null:o,{i:l,r:c}=e,a=t&&t.r,f=l.refs===ie?l.refs={}:l.refs,d=l.setupState,p=Y(d),m=d===ie?fo:x=>ee(p,x);if(a!=null&&a!==c){if(ar(t),ue(a))f[a]=null,m(a)&&(d[a]=null);else if(fe(a)){a.value=null;const x=t;x.k&&(f[x.k]=null)}}if(K(c))yn(c,l,12,[i,f]);else{const x=ue(c),A=fe(c);if(x||A){const k=()=>{if(e.f){const N=x?m(c)?d[c]:f[c]:c.value;if(r)D(N)&&Fs(N,o);else if(D(N))N.includes(o)||N.push(o);else if(x)f[c]=[o],m(c)&&(d[c]=f[c]);else{const I=[o];c.value=I,e.k&&(f[e.k]=I)}}else x?(f[c]=i,m(c)&&(d[c]=i)):A&&(c.value=i,e.k&&(f[e.k]=i))};if(i){const N=()=>{k(),Fn.delete(e)};N.id=-1,Fn.set(e,N),Re(N,n)}else ar(e),k()}}}function ar(e){const t=Fn.get(e);t&&(t.flags|=8,Fn.delete(e))}Kn().requestIdleCallback;Kn().cancelIdleCallback;const Qt=e=>!!e.type.__asyncLoader,zn=e=>e.type.__isKeepAlive;function Kl(e,t){Xo(e,"a",t)}function Ul(e,t){Xo(e,"da",t)}function Xo(e,t,n=me){const s=e.__wdc||(e.__wdc=()=>{let r=n;for(;r;){if(r.isDeactivated)return;r=r.parent}return e()});if(Jn(t,s,n),n){let r=n.parent;for(;r&&r.parent;)zn(r.parent.vnode)&&Wl(s,t,n,r),r=r.parent}}function Wl(e,t,n,s){const r=Jn(t,e,s,!0);ti(()=>{Fs(s[t],r)},n)}function Jn(e,t,n=me,s=!1){if(n){const r=n[e]||(n[e]=[]),o=t.__weh||(t.__weh=(...i)=>{st();const l=_n(n),c=je(t,n,e,i);return l(),rt(),c});return s?r.unshift(o):r.push(o),o}}const ot=e=>(t,n=me)=>{(!fn||e==="sp")&&Jn(e,(...s)=>t(...s),n)},ql=ot("bm"),Zo=ot("m"),Gl=ot("bu"),zl=ot("u"),ei=ot("bum"),ti=ot("um"),Jl=ot("sp"),Ql=ot("rtg"),Yl=ot("rtc");function Xl(e,t=me){Jn("ec",e,t)}const ni="components";function Lu(e,t){return ri(ni,e,!0,t)||e}const si=Symbol.for("v-ndc");function Nu(e){return ue(e)?ri(ni,e,!1)||e:e||si}function ri(e,t,n=!0,s=!1){const r=Ae||me;if(r){const o=r.type;{const l=Kc(o,!1);if(l&&(l===t||l===Ne(t)||l===Bn(Ne(t))))return o}const i=dr(r[e]||o[e],t)||dr(r.appContext[e],t);return!i&&s?o:i}}function dr(e,t){return e&&(e[t]||e[Ne(t)]||e[Bn(Ne(t))])}function Fu(e,t,n,s){let r;const o=n,i=D(e);if(i||ue(e)){const l=i&&gt(e);let c=!1,a=!1;l&&(c=!Ie(e),a=mt(e),e=Un(e)),r=new Array(e.length);for(let f=0,d=e.length;f<d;f++)r[f]=t(c?a?Mn(he(e[f])):he(e[f]):e[f],f,void 0,o)}else if(typeof e=="number"){r=new Array(e);for(let l=0;l<e;l++)r[l]=t(l+1,l,void 0,o)}else if(ne(e))if(e[Symbol.iterator])r=Array.from(e,(l,c)=>t(l,c,void 0,o));else{const l=Object.keys(e);r=new Array(l.length);for(let c=0,a=l.length;c<a;c++){const f=l[c];r[c]=t(e[f],f,c,o)}}else r=[];return r}const xs=e=>e?Ci(e)?Xn(e):xs(e.parent):null,Yt=de(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>xs(e.parent),$root:e=>xs(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>ii(e),$forceUpdate:e=>e.f||(e.f=()=>{zs(e.update)}),$nextTick:e=>e.n||(e.n=Gn.bind(e.proxy)),$watch:e=>bc.bind(e)}),cs=(e,t)=>e!==ie&&!e.__isScriptSetup&&ee(e,t),Zl={get({_:e},t){if(t==="__v_skip")return!0;const{ctx:n,setupState:s,data:r,props:o,accessCache:i,type:l,appContext:c}=e;let a;if(t[0]!=="$"){const m=i[t];if(m!==void 0)switch(m){case 1:return s[t];case 2:return r[t];case 4:return n[t];case 3:return o[t]}else{if(cs(s,t))return i[t]=1,s[t];if(r!==ie&&ee(r,t))return i[t]=2,r[t];if((a=e.propsOptions[0])&&ee(a,t))return i[t]=3,o[t];if(n!==ie&&ee(n,t))return i[t]=4,n[t];Es&&(i[t]=0)}}const f=Yt[t];let d,p;if(f)return t==="$attrs"&&ge(e.attrs,"get",""),f(e);if((d=l.__cssModules)&&(d=d[t]))return d;if(n!==ie&&ee(n,t))return i[t]=4,n[t];if(p=c.config.globalProperties,ee(p,t))return p[t]},set({_:e},t,n){const{data:s,setupState:r,ctx:o}=e;return cs(r,t)?(r[t]=n,!0):s!==ie&&ee(s,t)?(s[t]=n,!0):ee(e.props,t)||t[0]==="$"&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:s,appContext:r,propsOptions:o,type:i}},l){let c,a;return!!(n[l]||e!==ie&&l[0]!=="$"&&ee(e,l)||cs(t,l)||(c=o[0])&&ee(c,l)||ee(s,l)||ee(Yt,l)||ee(r.config.globalProperties,l)||(a=i.__cssModules)&&a[l])},defineProperty(e,t,n){return n.get!=null?e._.accessCache[t]=0:ee(n,"value")&&this.set(e,t,n.value,null),Reflect.defineProperty(e,t,n)}};function hr(e){return D(e)?e.reduce((t,n)=>(t[n]=null,t),{}):e}let Es=!0;function ec(e){const t=ii(e),n=e.proxy,s=e.ctx;Es=!1,t.beforeCreate&&pr(t.beforeCreate,e,"bc");const{data:r,computed:o,methods:i,watch:l,provide:c,inject:a,created:f,beforeMount:d,mounted:p,beforeUpdate:m,updated:x,activated:A,deactivated:k,beforeDestroy:N,beforeUnmount:I,destroyed:F,unmounted:L,render:V,renderTracked:se,renderTriggered:G,errorCaptured:W,serverPrefetch:T,expose:U,inheritAttrs:Q,components:P,directives:z,filters:ae}=t;if(a&&tc(a,s,null),i)for(const q in i){const X=i[q];K(X)&&(s[q]=X.bind(n))}if(r){const q=r.call(n,n);ne(q)&&(e.data=mn(q))}if(Es=!0,o)for(const q in o){const X=o[q],ze=K(X)?X.bind(n,n):K(X.get)?X.get.bind(n,n):qe,it=!K(X)&&K(X.set)?X.set.bind(n):qe,$e=Me({get:ze,set:it});Object.defineProperty(s,q,{enumerable:!0,configurable:!0,get:()=>$e.value,set:Se=>$e.value=Se})}if(l)for(const q in l)oi(l[q],s,n,q);if(c){const q=K(c)?c.call(n):c;Reflect.ownKeys(q).forEach(X=>{Cn(X,q[X])})}f&&pr(f,e,"c");function re(q,X){D(X)?X.forEach(ze=>q(ze.bind(n))):X&&q(X.bind(n))}if(re(ql,d),re(Zo,p),re(Gl,m),re(zl,x),re(Kl,A),re(Ul,k),re(Xl,W),re(Yl,se),re(Ql,G),re(ei,I),re(ti,L),re(Jl,T),D(U))if(U.length){const q=e.exposed||(e.exposed={});U.forEach(X=>{Object.defineProperty(q,X,{get:()=>n[X],set:ze=>n[X]=ze,enumerable:!0})})}else e.exposed||(e.exposed={});V&&e.render===qe&&(e.render=V),Q!=null&&(e.inheritAttrs=Q),P&&(e.components=P),z&&(e.directives=z),T&&Yo(e)}function tc(e,t,n=qe){D(e)&&(e=ws(e));for(const s in e){const r=e[s];let o;ne(r)?"default"in r?o=Le(r.from||s,r.default,!0):o=Le(r.from||s):o=Le(r),fe(o)?Object.defineProperty(t,s,{enumerable:!0,configurable:!0,get:()=>o.value,set:i=>o.value=i}):t[s]=o}}function pr(e,t,n){je(D(e)?e.map(s=>s.bind(t.proxy)):e.bind(t.proxy),t,n)}function oi(e,t,n,s){let r=s.includes(".")?vi(n,s):()=>n[s];if(ue(e)){const o=t[e];K(o)&&Xt(r,o)}else if(K(e))Xt(r,e.bind(n));else if(ne(e))if(D(e))e.forEach(o=>oi(o,t,n,s));else{const o=K(e.handler)?e.handler.bind(n):t[e.handler];K(o)&&Xt(r,o,e)}}function ii(e){const t=e.type,{mixins:n,extends:s}=t,{mixins:r,optionsCache:o,config:{optionMergeStrategies:i}}=e.appContext,l=o.get(t);let c;return l?c=l:!r.length&&!n&&!s?c=t:(c={},r.length&&r.forEach(a=>jn(c,a,i,!0)),jn(c,t,i)),ne(t)&&o.set(t,c),c}function jn(e,t,n,s=!1){const{mixins:r,extends:o}=t;o&&jn(e,o,n,!0),r&&r.forEach(i=>jn(e,i,n,!0));for(const i in t)if(!(s&&i==="expose")){const l=nc[i]||n&&n[i];e[i]=l?l(e[i],t[i]):t[i]}return e}const nc={data:gr,props:mr,emits:mr,methods:Wt,computed:Wt,beforeCreate:_e,created:_e,beforeMount:_e,mounted:_e,beforeUpdate:_e,updated:_e,beforeDestroy:_e,beforeUnmount:_e,destroyed:_e,unmounted:_e,activated:_e,deactivated:_e,errorCaptured:_e,serverPrefetch:_e,components:Wt,directives:Wt,watch:rc,provide:gr,inject:sc};function gr(e,t){return t?e?function(){return de(K(e)?e.call(this,this):e,K(t)?t.call(this,this):t)}:t:e}function sc(e,t){return Wt(ws(e),ws(t))}function ws(e){if(D(e)){const t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function _e(e,t){return e?[...new Set([].concat(e,t))]:t}function Wt(e,t){return e?de(Object.create(null),e,t):t}function mr(e,t){return e?D(e)&&D(t)?[...new Set([...e,...t])]:de(Object.create(null),hr(e),hr(t??{})):t}function rc(e,t){if(!e)return t;if(!t)return e;const n=de(Object.create(null),e);for(const s in t)n[s]=_e(e[s],t[s]);return n}function li(){return{app:null,config:{isNativeTag:fo,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}let oc=0;function ic(e,t){return function(s,r=null){K(s)||(s=de({},s)),r!=null&&!ne(r)&&(r=null);const o=li(),i=new WeakSet,l=[];let c=!1;const a=o.app={_uid:oc++,_component:s,_props:r,_container:null,_context:o,_instance:null,version:Wc,get config(){return o.config},set config(f){},use(f,...d){return i.has(f)||(f&&K(f.install)?(i.add(f),f.install(a,...d)):K(f)&&(i.add(f),f(a,...d))),a},mixin(f){return o.mixins.includes(f)||o.mixins.push(f),a},component(f,d){return d?(o.components[f]=d,a):o.components[f]},directive(f,d){return d?(o.directives[f]=d,a):o.directives[f]},mount(f,d,p){if(!c){const m=a._ceVNode||we(s,r);return m.appContext=o,p===!0?p="svg":p===!1&&(p=void 0),e(m,f,p),c=!0,a._container=f,f.__vue_app__=a,Xn(m.component)}},onUnmount(f){l.push(f)},unmount(){c&&(je(l,a._instance,16),e(null,a._container),delete a._container.__vue_app__)},provide(f,d){return o.provides[f]=d,a},runWithContext(f){const d=Rt;Rt=a;try{return f()}finally{Rt=d}}};return a}}let Rt=null;function Cn(e,t){if(me){let n=me.provides;const s=me.parent&&me.parent.provides;s===n&&(n=me.provides=Object.create(s)),n[e]=t}}function Le(e,t,n=!1){const s=Xs();if(s||Rt){let r=Rt?Rt._context.provides:s?s.parent==null||s.ce?s.vnode.appContext&&s.vnode.appContext.provides:s.parent.provides:void 0;if(r&&e in r)return r[e];if(arguments.length>1)return n&&K(t)?t.call(s&&s.proxy):t}}function lc(){return!!(Xs()||Rt)}const ci={},fi=()=>Object.create(ci),ui=e=>Object.getPrototypeOf(e)===ci;function cc(e,t,n,s=!1){const r={},o=fi();e.propsDefaults=Object.create(null),ai(e,t,r,o);for(const i in e.propsOptions[0])i in r||(r[i]=void 0);n?e.props=s?r:Fo(r):e.type.props?e.props=r:e.props=o,e.attrs=o}function fc(e,t,n,s){const{props:r,attrs:o,vnode:{patchFlag:i}}=e,l=Y(r),[c]=e.propsOptions;let a=!1;if((s||i>0)&&!(i&16)){if(i&8){const f=e.vnode.dynamicProps;for(let d=0;d<f.length;d++){let p=f[d];if(Qn(e.emitsOptions,p))continue;const m=t[p];if(c)if(ee(o,p))m!==o[p]&&(o[p]=m,a=!0);else{const x=Ne(p);r[x]=Cs(c,l,x,m,e,!1)}else m!==o[p]&&(o[p]=m,a=!0)}}}else{ai(e,t,r,o)&&(a=!0);let f;for(const d in l)(!t||!ee(t,d)&&((f=_t(d))===d||!ee(t,f)))&&(c?n&&(n[d]!==void 0||n[f]!==void 0)&&(r[d]=Cs(c,l,d,void 0,e,!0)):delete r[d]);if(o!==l)for(const d in o)(!t||!ee(t,d))&&(delete o[d],a=!0)}a&&et(e.attrs,"set","")}function ai(e,t,n,s){const[r,o]=e.propsOptions;let i=!1,l;if(t)for(let c in t){if(qt(c))continue;const a=t[c];let f;r&&ee(r,f=Ne(c))?!o||!o.includes(f)?n[f]=a:(l||(l={}))[f]=a:Qn(e.emitsOptions,c)||(!(c in s)||a!==s[c])&&(s[c]=a,i=!0)}if(o){const c=Y(n),a=l||ie;for(let f=0;f<o.length;f++){const d=o[f];n[d]=Cs(r,c,d,a[d],e,!ee(a,d))}}return i}function Cs(e,t,n,s,r,o){const i=e[n];if(i!=null){const l=ee(i,"default");if(l&&s===void 0){const c=i.default;if(i.type!==Function&&!i.skipFactory&&K(c)){const{propsDefaults:a}=r;if(n in a)s=a[n];else{const f=_n(r);s=a[n]=c.call(null,t),f()}}else s=c;r.ce&&r.ce._setProp(n,s)}i[0]&&(o&&!l?s=!1:i[1]&&(s===""||s===_t(n))&&(s=!0))}return s}const uc=new WeakMap;function di(e,t,n=!1){const s=n?uc:t.propsCache,r=s.get(e);if(r)return r;const o=e.props,i={},l=[];let c=!1;if(!K(e)){const f=d=>{c=!0;const[p,m]=di(d,t,!0);de(i,p),m&&l.push(...m)};!n&&t.mixins.length&&t.mixins.forEach(f),e.extends&&f(e.extends),e.mixins&&e.mixins.forEach(f)}if(!o&&!c)return ne(e)&&s.set(e,Lt),Lt;if(D(o))for(let f=0;f<o.length;f++){const d=Ne(o[f]);yr(d)&&(i[d]=ie)}else if(o)for(const f in o){const d=Ne(f);if(yr(d)){const p=o[f],m=i[d]=D(p)||K(p)?{type:p}:de({},p),x=m.type;let A=!1,k=!0;if(D(x))for(let N=0;N<x.length;++N){const I=x[N],F=K(I)&&I.name;if(F==="Boolean"){A=!0;break}else F==="String"&&(k=!1)}else A=K(x)&&x.name==="Boolean";m[0]=A,m[1]=k,(A||ee(m,"default"))&&l.push(d)}}const a=[i,l];return ne(e)&&s.set(e,a),a}function yr(e){return e[0]!=="$"&&!qt(e)}const Js=e=>e==="_"||e==="_ctx"||e==="$stable",Qs=e=>D(e)?e.map(We):[We(e)],ac=(e,t,n)=>{if(t._n)return t;const s=$l((...r)=>Qs(t(...r)),n);return s._c=!1,s},hi=(e,t,n)=>{const s=e._ctx;for(const r in e){if(Js(r))continue;const o=e[r];if(K(o))t[r]=ac(r,o,s);else if(o!=null){const i=Qs(o);t[r]=()=>i}}},pi=(e,t)=>{const n=Qs(t);e.slots.default=()=>n},gi=(e,t,n)=>{for(const s in t)(n||!Js(s))&&(e[s]=t[s])},dc=(e,t,n)=>{const s=e.slots=fi();if(e.vnode.shapeFlag&32){const r=t._;r?(gi(s,t,n),n&&po(s,"_",r,!0)):hi(t,s)}else t&&pi(e,t)},hc=(e,t,n)=>{const{vnode:s,slots:r}=e;let o=!0,i=ie;if(s.shapeFlag&32){const l=t._;l?n&&l===1?o=!1:gi(r,t,n):(o=!t.$stable,hi(t,r)),i=t}else t&&(pi(e,t),i={default:1});if(o)for(const l in r)!Js(l)&&i[l]==null&&delete r[l]},Re=Pc;function pc(e){return gc(e)}function gc(e,t){const n=Kn();n.__VUE__=!0;const{insert:s,remove:r,patchProp:o,createElement:i,createText:l,createComment:c,setText:a,setElementText:f,parentNode:d,nextSibling:p,setScopeId:m=qe,insertStaticContent:x}=e,A=(u,h,g,_=null,b=null,y=null,C=void 0,w=null,E=!!h.dynamicChildren)=>{if(u===h)return;u&&!wt(u,h)&&(_=v(u),Se(u,b,y,!0),u=null),h.patchFlag===-2&&(E=!1,h.dynamicChildren=null);const{type:S,ref:H,shapeFlag:O}=h;switch(S){case Yn:k(u,h,g,_);break;case be:N(u,h,g,_);break;case Rn:u==null&&I(h,g,_,C);break;case Ue:P(u,h,g,_,b,y,C,w,E);break;default:O&1?V(u,h,g,_,b,y,C,w,E):O&6?z(u,h,g,_,b,y,C,w,E):(O&64||O&128)&&S.process(u,h,g,_,b,y,C,w,E,j)}H!=null&&b?Jt(H,u&&u.ref,y,h||u,!h):H==null&&u&&u.ref!=null&&Jt(u.ref,null,y,u,!0)},k=(u,h,g,_)=>{if(u==null)s(h.el=l(h.children),g,_);else{const b=h.el=u.el;h.children!==u.children&&a(b,h.children)}},N=(u,h,g,_)=>{u==null?s(h.el=c(h.children||""),g,_):h.el=u.el},I=(u,h,g,_)=>{[u.el,u.anchor]=x(u.children,h,g,_,u.el,u.anchor)},F=({el:u,anchor:h},g,_)=>{let b;for(;u&&u!==h;)b=p(u),s(u,g,_),u=b;s(h,g,_)},L=({el:u,anchor:h})=>{let g;for(;u&&u!==h;)g=p(u),r(u),u=g;r(h)},V=(u,h,g,_,b,y,C,w,E)=>{h.type==="svg"?C="svg":h.type==="math"&&(C="mathml"),u==null?se(h,g,_,b,y,C,w,E):T(u,h,b,y,C,w,E)},se=(u,h,g,_,b,y,C,w)=>{let E,S;const{props:H,shapeFlag:O,transition:$,dirs:B}=u;if(E=u.el=i(u.type,y,H&&H.is,H),O&8?f(E,u.children):O&16&&W(u.children,E,null,_,b,fs(u,y),C,w),B&&vt(u,null,_,"created"),G(E,u,u.scopeId,C,_),H){for(const le in H)le!=="value"&&!qt(le)&&o(E,le,null,H[le],y,_);"value"in H&&o(E,"value",null,H.value,y),(S=H.onVnodeBeforeMount)&&Be(S,_,u)}B&&vt(u,null,_,"beforeMount");const J=mc(b,$);J&&$.beforeEnter(E),s(E,h,g),((S=H&&H.onVnodeMounted)||J||B)&&Re(()=>{S&&Be(S,_,u),J&&$.enter(E),B&&vt(u,null,_,"mounted")},b)},G=(u,h,g,_,b)=>{if(g&&m(u,g),_)for(let y=0;y<_.length;y++)m(u,_[y]);if(b){let y=b.subTree;if(h===y||Si(y.type)&&(y.ssContent===h||y.ssFallback===h)){const C=b.vnode;G(u,C,C.scopeId,C.slotScopeIds,b.parent)}}},W=(u,h,g,_,b,y,C,w,E=0)=>{for(let S=E;S<u.length;S++){const H=u[S]=w?at(u[S]):We(u[S]);A(null,H,h,g,_,b,y,C,w)}},T=(u,h,g,_,b,y,C)=>{const w=h.el=u.el;let{patchFlag:E,dynamicChildren:S,dirs:H}=h;E|=u.patchFlag&16;const O=u.props||ie,$=h.props||ie;let B;if(g&&bt(g,!1),(B=$.onVnodeBeforeUpdate)&&Be(B,g,h,u),H&&vt(h,u,g,"beforeUpdate"),g&&bt(g,!0),(O.innerHTML&&$.innerHTML==null||O.textContent&&$.textContent==null)&&f(w,""),S?U(u.dynamicChildren,S,w,g,_,fs(h,b),y):C||X(u,h,w,null,g,_,fs(h,b),y,!1),E>0){if(E&16)Q(w,O,$,g,b);else if(E&2&&O.class!==$.class&&o(w,"class",null,$.class,b),E&4&&o(w,"style",O.style,$.style,b),E&8){const J=h.dynamicProps;for(let le=0;le<J.length;le++){const te=J[le],xe=O[te],Ee=$[te];(Ee!==xe||te==="value")&&o(w,te,xe,Ee,b,g)}}E&1&&u.children!==h.children&&f(w,h.children)}else!C&&S==null&&Q(w,O,$,g,b);((B=$.onVnodeUpdated)||H)&&Re(()=>{B&&Be(B,g,h,u),H&&vt(h,u,g,"updated")},_)},U=(u,h,g,_,b,y,C)=>{for(let w=0;w<h.length;w++){const E=u[w],S=h[w],H=E.el&&(E.type===Ue||!wt(E,S)||E.shapeFlag&198)?d(E.el):g;A(E,S,H,null,_,b,y,C,!0)}},Q=(u,h,g,_,b)=>{if(h!==g){if(h!==ie)for(const y in h)!qt(y)&&!(y in g)&&o(u,y,h[y],null,b,_);for(const y in g){if(qt(y))continue;const C=g[y],w=h[y];C!==w&&y!=="value"&&o(u,y,w,C,b,_)}"value"in g&&o(u,"value",h.value,g.value,b)}},P=(u,h,g,_,b,y,C,w,E)=>{const S=h.el=u?u.el:l(""),H=h.anchor=u?u.anchor:l("");let{patchFlag:O,dynamicChildren:$,slotScopeIds:B}=h;B&&(w=w?w.concat(B):B),u==null?(s(S,g,_),s(H,g,_),W(h.children||[],g,H,b,y,C,w,E)):O>0&&O&64&&$&&u.dynamicChildren?(U(u.dynamicChildren,$,g,b,y,C,w),(h.key!=null||b&&h===b.subTree)&&mi(u,h,!0)):X(u,h,g,H,b,y,C,w,E)},z=(u,h,g,_,b,y,C,w,E)=>{h.slotScopeIds=w,u==null?h.shapeFlag&512?b.ctx.activate(h,g,_,C,E):ae(h,g,_,b,y,C,E):ye(u,h,E)},ae=(u,h,g,_,b,y,C)=>{const w=u.component=$c(u,_,b);if(zn(u)&&(w.ctx.renderer=j),Hc(w,!1,C),w.asyncDep){if(b&&b.registerDep(w,re,C),!u.el){const E=w.subTree=we(be);N(null,E,h,g),u.placeholder=E.el}}else re(w,u,h,g,b,y,C)},ye=(u,h,g)=>{const _=h.component=u.component;if(Rc(u,h,g))if(_.asyncDep&&!_.asyncResolved){q(_,h,g);return}else _.next=h,_.update();else h.el=u.el,_.vnode=h},re=(u,h,g,_,b,y,C)=>{const w=()=>{if(u.isMounted){let{next:O,bu:$,u:B,parent:J,vnode:le}=u;{const ke=yi(u);if(ke){O&&(O.el=le.el,q(u,O,C)),ke.asyncDep.then(()=>{u.isUnmounted||w()});return}}let te=O,xe;bt(u,!1),O?(O.el=le.el,q(u,O,C)):O=le,$&&wn($),(xe=O.props&&O.props.onVnodeBeforeUpdate)&&Be(xe,J,O,le),bt(u,!0);const Ee=vr(u),He=u.subTree;u.subTree=Ee,A(He,Ee,d(He.el),v(He),u,b,y),O.el=Ee.el,te===null&&Ac(u,Ee.el),B&&Re(B,b),(xe=O.props&&O.props.onVnodeUpdated)&&Re(()=>Be(xe,J,O,le),b)}else{let O;const{el:$,props:B}=h,{bm:J,m:le,parent:te,root:xe,type:Ee}=u,He=Qt(h);bt(u,!1),J&&wn(J),!He&&(O=B&&B.onVnodeBeforeMount)&&Be(O,te,h),bt(u,!0);{xe.ce&&xe.ce._def.shadowRoot!==!1&&xe.ce._injectChildStyle(Ee);const ke=u.subTree=vr(u);A(null,ke,g,_,u,b,y),h.el=ke.el}if(le&&Re(le,b),!He&&(O=B&&B.onVnodeMounted)){const ke=h;Re(()=>Be(O,te,ke),b)}(h.shapeFlag&256||te&&Qt(te.vnode)&&te.vnode.shapeFlag&256)&&u.a&&Re(u.a,b),u.isMounted=!0,h=g=_=null}};u.scope.on();const E=u.effect=new So(w);u.scope.off();const S=u.update=E.run.bind(E),H=u.job=E.runIfDirty.bind(E);H.i=u,H.id=u.uid,E.scheduler=()=>zs(H),bt(u,!0),S()},q=(u,h,g)=>{h.component=u;const _=u.vnode.props;u.vnode=h,u.next=null,fc(u,h.props,_,g),hc(u,h.children,g),st(),fr(u),rt()},X=(u,h,g,_,b,y,C,w,E=!1)=>{const S=u&&u.children,H=u?u.shapeFlag:0,O=h.children,{patchFlag:$,shapeFlag:B}=h;if($>0){if($&128){it(S,O,g,_,b,y,C,w,E);return}else if($&256){ze(S,O,g,_,b,y,C,w,E);return}}B&8?(H&16&&Te(S,b,y),O!==S&&f(g,O)):H&16?B&16?it(S,O,g,_,b,y,C,w,E):Te(S,b,y,!0):(H&8&&f(g,""),B&16&&W(O,g,_,b,y,C,w,E))},ze=(u,h,g,_,b,y,C,w,E)=>{u=u||Lt,h=h||Lt;const S=u.length,H=h.length,O=Math.min(S,H);let $;for($=0;$<O;$++){const B=h[$]=E?at(h[$]):We(h[$]);A(u[$],B,g,null,b,y,C,w,E)}S>H?Te(u,b,y,!0,!1,O):W(h,g,_,b,y,C,w,E,O)},it=(u,h,g,_,b,y,C,w,E)=>{let S=0;const H=h.length;let O=u.length-1,$=H-1;for(;S<=O&&S<=$;){const B=u[S],J=h[S]=E?at(h[S]):We(h[S]);if(wt(B,J))A(B,J,g,null,b,y,C,w,E);else break;S++}for(;S<=O&&S<=$;){const B=u[O],J=h[$]=E?at(h[$]):We(h[$]);if(wt(B,J))A(B,J,g,null,b,y,C,w,E);else break;O--,$--}if(S>O){if(S<=$){const B=$+1,J=B<H?h[B].el:_;for(;S<=$;)A(null,h[S]=E?at(h[S]):We(h[S]),g,J,b,y,C,w,E),S++}}else if(S>$)for(;S<=O;)Se(u[S],b,y,!0),S++;else{const B=S,J=S,le=new Map;for(S=J;S<=$;S++){const Ce=h[S]=E?at(h[S]):We(h[S]);Ce.key!=null&&le.set(Ce.key,S)}let te,xe=0;const Ee=$-J+1;let He=!1,ke=0;const Vt=new Array(Ee);for(S=0;S<Ee;S++)Vt[S]=0;for(S=B;S<=O;S++){const Ce=u[S];if(xe>=Ee){Se(Ce,b,y,!0);continue}let Ve;if(Ce.key!=null)Ve=le.get(Ce.key);else for(te=J;te<=$;te++)if(Vt[te-J]===0&&wt(Ce,h[te])){Ve=te;break}Ve===void 0?Se(Ce,b,y,!0):(Vt[Ve-J]=S+1,Ve>=ke?ke=Ve:He=!0,A(Ce,h[Ve],g,null,b,y,C,w,E),xe++)}const nr=He?yc(Vt):Lt;for(te=nr.length-1,S=Ee-1;S>=0;S--){const Ce=J+S,Ve=h[Ce],sr=h[Ce+1],rr=Ce+1<H?sr.el||sr.placeholder:_;Vt[S]===0?A(null,Ve,g,rr,b,y,C,w,E):He&&(te<0||S!==nr[te]?$e(Ve,g,rr,2):te--)}}},$e=(u,h,g,_,b=null)=>{const{el:y,type:C,transition:w,children:E,shapeFlag:S}=u;if(S&6){$e(u.component.subTree,h,g,_);return}if(S&128){u.suspense.move(h,g,_);return}if(S&64){C.move(u,h,g,j);return}if(C===Ue){s(y,h,g);for(let O=0;O<E.length;O++)$e(E[O],h,g,_);s(u.anchor,h,g);return}if(C===Rn){F(u,h,g);return}if(_!==2&&S&1&&w)if(_===0)w.beforeEnter(y),s(y,h,g),Re(()=>w.enter(y),b);else{const{leave:O,delayLeave:$,afterLeave:B}=w,J=()=>{u.ctx.isUnmounted?r(y):s(y,h,g)},le=()=>{y._isLeaving&&y[Ze](!0),O(y,()=>{J(),B&&B()})};$?$(y,J,le):le()}else s(y,h,g)},Se=(u,h,g,_=!1,b=!1)=>{const{type:y,props:C,ref:w,children:E,dynamicChildren:S,shapeFlag:H,patchFlag:O,dirs:$,cacheIndex:B}=u;if(O===-2&&(b=!1),w!=null&&(st(),Jt(w,null,g,u,!0),rt()),B!=null&&(h.renderCache[B]=void 0),H&256){h.ctx.deactivate(u);return}const J=H&1&&$,le=!Qt(u);let te;if(le&&(te=C&&C.onVnodeBeforeUnmount)&&Be(te,h,u),H&6)vn(u.component,g,_);else{if(H&128){u.suspense.unmount(g,_);return}J&&vt(u,null,h,"beforeUnmount"),H&64?u.type.remove(u,h,g,j,_):S&&!S.hasOnce&&(y!==Ue||O>0&&O&64)?Te(S,h,g,!1,!0):(y===Ue&&O&384||!b&&H&16)&&Te(E,h,g),_&&At(u)}(le&&(te=C&&C.onVnodeUnmounted)||J)&&Re(()=>{te&&Be(te,h,u),J&&vt(u,null,h,"unmounted")},g)},At=u=>{const{type:h,el:g,anchor:_,transition:b}=u;if(h===Ue){Pt(g,_);return}if(h===Rn){L(u);return}const y=()=>{r(g),b&&!b.persisted&&b.afterLeave&&b.afterLeave()};if(u.shapeFlag&1&&b&&!b.persisted){const{leave:C,delayLeave:w}=b,E=()=>C(g,y);w?w(u.el,y,E):E()}else y()},Pt=(u,h)=>{let g;for(;u!==h;)g=p(u),r(u),u=g;r(h)},vn=(u,h,g)=>{const{bum:_,scope:b,job:y,subTree:C,um:w,m:E,a:S}=u;_r(E),_r(S),_&&wn(_),b.stop(),y&&(y.flags|=8,Se(C,u,h,g)),w&&Re(w,h),Re(()=>{u.isUnmounted=!0},h)},Te=(u,h,g,_=!1,b=!1,y=0)=>{for(let C=y;C<u.length;C++)Se(u[C],h,g,_,b)},v=u=>{if(u.shapeFlag&6)return v(u.component.subTree);if(u.shapeFlag&128)return u.suspense.next();const h=p(u.anchor||u.el),g=h&&h[Hl];return g?p(g):h};let M=!1;const R=(u,h,g)=>{u==null?h._vnode&&Se(h._vnode,null,null,!0):A(h._vnode||null,u,h,null,null,null,g),h._vnode=u,M||(M=!0,fr(),Vo(),M=!1)},j={p:A,um:Se,m:$e,r:At,mt:ae,mc:W,pc:X,pbc:U,n:v,o:e};return{render:R,hydrate:void 0,createApp:ic(R)}}function fs({type:e,props:t},n){return n==="svg"&&e==="foreignObject"||n==="mathml"&&e==="annotation-xml"&&t&&t.encoding&&t.encoding.includes("html")?void 0:n}function bt({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function mc(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function mi(e,t,n=!1){const s=e.children,r=t.children;if(D(s)&&D(r))for(let o=0;o<s.length;o++){const i=s[o];let l=r[o];l.shapeFlag&1&&!l.dynamicChildren&&((l.patchFlag<=0||l.patchFlag===32)&&(l=r[o]=at(r[o]),l.el=i.el),!n&&l.patchFlag!==-2&&mi(i,l)),l.type===Yn&&l.patchFlag!==-1&&(l.el=i.el),l.type===be&&!l.el&&(l.el=i.el)}}function yc(e){const t=e.slice(),n=[0];let s,r,o,i,l;const c=e.length;for(s=0;s<c;s++){const a=e[s];if(a!==0){if(r=n[n.length-1],e[r]<a){t[s]=r,n.push(s);continue}for(o=0,i=n.length-1;o<i;)l=o+i>>1,e[n[l]]<a?o=l+1:i=l;a<e[n[o]]&&(o>0&&(t[s]=n[o-1]),n[o]=s)}}for(o=n.length,i=n[o-1];o-- >0;)n[o]=i,i=t[i];return n}function yi(e){const t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:yi(t)}function _r(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}const _c=Symbol.for("v-scx"),vc=()=>Le(_c);function Xt(e,t,n){return _i(e,t,n)}function _i(e,t,n=ie){const{immediate:s,deep:r,flush:o,once:i}=n,l=de({},n),c=t&&s||!t&&o!=="post";let a;if(fn){if(o==="sync"){const m=vc();a=m.__watcherHandles||(m.__watcherHandles=[])}else if(!c){const m=()=>{};return m.stop=qe,m.resume=qe,m.pause=qe,m}}const f=me;l.call=(m,x,A)=>je(m,f,x,A);let d=!1;o==="post"?l.scheduler=m=>{Re(m,f&&f.suspense)}:o!=="sync"&&(d=!0,l.scheduler=(m,x)=>{x?m():zs(m)}),l.augmentJob=m=>{t&&(m.flags|=4),d&&(m.flags|=2,f&&(m.id=f.uid,m.i=f))};const p=Nl(e,t,l);return fn&&(a?a.push(p):c&&p()),p}function bc(e,t,n){const s=this.proxy,r=ue(e)?e.includes(".")?vi(s,e):()=>s[e]:e.bind(s,s);let o;K(t)?o=t:(o=t.handler,n=t);const i=_n(this),l=_i(r,o.bind(s),n);return i(),l}function vi(e,t){const n=t.split(".");return()=>{let s=e;for(let r=0;r<n.length&&s;r++)s=s[n[r]];return s}}const Sc=(e,t)=>t==="modelValue"||t==="model-value"?e.modelModifiers:e[`${t}Modifiers`]||e[`${Ne(t)}Modifiers`]||e[`${_t(t)}Modifiers`];function xc(e,t,...n){if(e.isUnmounted)return;const s=e.vnode.props||ie;let r=n;const o=t.startsWith("update:"),i=o&&Sc(s,t.slice(7));i&&(i.trim&&(r=n.map(f=>ue(f)?f.trim():f)),i.number&&(r=n.map(Tn)));let l,c=s[l=ns(t)]||s[l=ns(Ne(t))];!c&&o&&(c=s[l=ns(_t(t))]),c&&je(c,e,6,r);const a=s[l+"Once"];if(a){if(!e.emitted)e.emitted={};else if(e.emitted[l])return;e.emitted[l]=!0,je(a,e,6,r)}}const Ec=new WeakMap;function bi(e,t,n=!1){const s=n?Ec:t.emitsCache,r=s.get(e);if(r!==void 0)return r;const o=e.emits;let i={},l=!1;if(!K(e)){const c=a=>{const f=bi(a,t,!0);f&&(l=!0,de(i,f))};!n&&t.mixins.length&&t.mixins.forEach(c),e.extends&&c(e.extends),e.mixins&&e.mixins.forEach(c)}return!o&&!l?(ne(e)&&s.set(e,null),null):(D(o)?o.forEach(c=>i[c]=null):de(i,o),ne(e)&&s.set(e,i),i)}function Qn(e,t){return!e||!kn(t)?!1:(t=t.slice(2).replace(/Once$/,""),ee(e,t[0].toLowerCase()+t.slice(1))||ee(e,_t(t))||ee(e,t))}function vr(e){const{type:t,vnode:n,proxy:s,withProxy:r,propsOptions:[o],slots:i,attrs:l,emit:c,render:a,renderCache:f,props:d,data:p,setupState:m,ctx:x,inheritAttrs:A}=e,k=Nn(e);let N,I;try{if(n.shapeFlag&4){const L=r||s,V=L;N=We(a.call(V,L,f,d,m,p,x)),I=l}else{const L=t;N=We(L.length>1?L(d,{attrs:l,slots:i,emit:c}):L(d,null)),I=t.props?l:wc(l)}}catch(L){Zt.length=0,qn(L,e,1),N=we(be)}let F=N;if(I&&A!==!1){const L=Object.keys(I),{shapeFlag:V}=F;L.length&&V&7&&(o&&L.some(Ns)&&(I=Cc(I,o)),F=yt(F,I,!1,!0))}return n.dirs&&(F=yt(F,null,!1,!0),F.dirs=F.dirs?F.dirs.concat(n.dirs):n.dirs),n.transition&&ln(F,n.transition),N=F,Nn(k),N}const wc=e=>{let t;for(const n in e)(n==="class"||n==="style"||kn(n))&&((t||(t={}))[n]=e[n]);return t},Cc=(e,t)=>{const n={};for(const s in e)(!Ns(s)||!(s.slice(9)in t))&&(n[s]=e[s]);return n};function Rc(e,t,n){const{props:s,children:r,component:o}=e,{props:i,children:l,patchFlag:c}=t,a=o.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return s?br(s,i,a):!!i;if(c&8){const f=t.dynamicProps;for(let d=0;d<f.length;d++){const p=f[d];if(i[p]!==s[p]&&!Qn(a,p))return!0}}}else return(r||l)&&(!l||!l.$stable)?!0:s===i?!1:s?i?br(s,i,a):!0:!!i;return!1}function br(e,t,n){const s=Object.keys(t);if(s.length!==Object.keys(e).length)return!0;for(let r=0;r<s.length;r++){const o=s[r];if(t[o]!==e[o]&&!Qn(n,o))return!0}return!1}function Ac({vnode:e,parent:t},n){for(;t;){const s=t.subTree;if(s.suspense&&s.suspense.activeBranch===e&&(s.el=e.el),s===e)(e=t.vnode).el=n,t=t.parent;else break}}const Si=e=>e.__isSuspense;function Pc(e,t){t&&t.pendingBranch?D(e)?t.effects.push(...e):t.effects.push(e):Dl(e)}const Ue=Symbol.for("v-fgt"),Yn=Symbol.for("v-txt"),be=Symbol.for("v-cmt"),Rn=Symbol.for("v-stc"),Zt=[];let Pe=null;function Tc(e=!1){Zt.push(Pe=e?null:[])}function Oc(){Zt.pop(),Pe=Zt[Zt.length-1]||null}let cn=1;function Dn(e,t=!1){cn+=e,e<0&&Pe&&t&&(Pe.hasOnce=!0)}function xi(e){return e.dynamicChildren=cn>0?Pe||Lt:null,Oc(),cn>0&&Pe&&Pe.push(e),e}function ju(e,t,n,s,r,o){return xi(wi(e,t,n,s,r,o,!0))}function Mc(e,t,n,s,r){return xi(we(e,t,n,s,r,!0))}function $n(e){return e?e.__v_isVNode===!0:!1}function wt(e,t){return e.type===t.type&&e.key===t.key}const Ei=({key:e})=>e??null,An=({ref:e,ref_key:t,ref_for:n})=>(typeof e=="number"&&(e=""+e),e!=null?ue(e)||fe(e)||K(e)?{i:Ae,r:e,k:t,f:!!n}:e:null);function wi(e,t=null,n=null,s=0,r=null,o=e===Ue?0:1,i=!1,l=!1){const c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&Ei(t),ref:t&&An(t),scopeId:Ko,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:o,patchFlag:s,dynamicProps:r,dynamicChildren:null,appContext:null,ctx:Ae};return l?(Ys(c,n),o&128&&e.normalize(c)):n&&(c.shapeFlag|=ue(n)?8:16),cn>0&&!i&&Pe&&(c.patchFlag>0||o&6)&&c.patchFlag!==32&&Pe.push(c),c}const we=Ic;function Ic(e,t=null,n=null,s=0,r=null,o=!1){if((!e||e===si)&&(e=be),$n(e)){const l=yt(e,t,!0);return n&&Ys(l,n),cn>0&&!o&&Pe&&(l.shapeFlag&6?Pe[Pe.indexOf(e)]=l:Pe.push(l)),l.patchFlag=-2,l}if(Uc(e)&&(e=e.__vccOpts),t){t=Lc(t);let{class:l,style:c}=t;l&&!ue(l)&&(t.class=$s(l)),ne(c)&&(qs(c)&&!D(c)&&(c=de({},c)),t.style=Ds(c))}const i=ue(e)?1:Si(e)?128:Uo(e)?64:ne(e)?4:K(e)?2:0;return wi(e,t,n,s,r,i,o,!0)}function Lc(e){return e?qs(e)||ui(e)?de({},e):e:null}function yt(e,t,n=!1,s=!1){const{props:r,ref:o,patchFlag:i,children:l,transition:c}=e,a=t?Fc(r||{},t):r,f={__v_isVNode:!0,__v_skip:!0,type:e.type,props:a,key:a&&Ei(a),ref:t&&t.ref?n&&o?D(o)?o.concat(An(t)):[o,An(t)]:An(t):o,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:l,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==Ue?i===-1?16:i|16:i,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&yt(e.ssContent),ssFallback:e.ssFallback&&yt(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&s&&ln(f,c.clone(f)),f}function Nc(e=" ",t=0){return we(Yn,null,e,t)}function Du(e,t){const n=we(Rn,null,e);return n.staticCount=t,n}function $u(e="",t=!1){return t?(Tc(),Mc(be,null,e)):we(be,null,e)}function We(e){return e==null||typeof e=="boolean"?we(be):D(e)?we(Ue,null,e.slice()):$n(e)?at(e):we(Yn,null,String(e))}function at(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:yt(e)}function Ys(e,t){let n=0;const{shapeFlag:s}=e;if(t==null)t=null;else if(D(t))n=16;else if(typeof t=="object")if(s&65){const r=t.default;r&&(r._c&&(r._d=!1),Ys(e,r()),r._c&&(r._d=!0));return}else{n=32;const r=t._;!r&&!ui(t)?t._ctx=Ae:r===3&&Ae&&(Ae.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}else K(t)?(t={default:t,_ctx:Ae},n=32):(t=String(t),s&64?(n=16,t=[Nc(t)]):n=8);e.children=t,e.shapeFlag|=n}function Fc(...e){const t={};for(let n=0;n<e.length;n++){const s=e[n];for(const r in s)if(r==="class")t.class!==s.class&&(t.class=$s([t.class,s.class]));else if(r==="style")t.style=Ds([t.style,s.style]);else if(kn(r)){const o=t[r],i=s[r];i&&o!==i&&!(D(o)&&o.includes(i))&&(t[r]=o?[].concat(o,i):i)}else r!==""&&(t[r]=s[r])}return t}function Be(e,t,n,s=null){je(e,t,7,[n,s])}const jc=li();let Dc=0;function $c(e,t,n){const s=e.type,r=(t?t.appContext:e.appContext)||jc,o={uid:Dc++,vnode:e,type:s,parent:t,appContext:r,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new _o(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(r.provides),ids:t?t.ids:["",0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:di(s,r),emitsOptions:bi(s,r),emit:null,emitted:null,propsDefaults:ie,inheritAttrs:s.inheritAttrs,ctx:ie,data:ie,props:ie,attrs:ie,slots:ie,refs:ie,setupState:ie,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=xc.bind(null,o),e.ce&&e.ce(o),o}let me=null;const Xs=()=>me||Ae;let Hn,Rs;{const e=Kn(),t=(n,s)=>{let r;return(r=e[n])||(r=e[n]=[]),r.push(s),o=>{r.length>1?r.forEach(i=>i(o)):r[0](o)}};Hn=t("__VUE_INSTANCE_SETTERS__",n=>me=n),Rs=t("__VUE_SSR_SETTERS__",n=>fn=n)}const _n=e=>{const t=me;return Hn(e),e.scope.on(),()=>{e.scope.off(),Hn(t)}},Sr=()=>{me&&me.scope.off(),Hn(null)};function Ci(e){return e.vnode.shapeFlag&4}let fn=!1;function Hc(e,t=!1,n=!1){t&&Rs(t);const{props:s,children:r}=e.vnode,o=Ci(e);cc(e,s,o,t),dc(e,r,n||t);const i=o?kc(e,t):void 0;return t&&Rs(!1),i}function kc(e,t){const n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,Zl);const{setup:s}=n;if(s){st();const r=e.setupContext=s.length>1?Bc(e):null,o=_n(e),i=yn(s,e,0,[e.props,r]),l=uo(i);if(rt(),o(),(l||e.sp)&&!Qt(e)&&Yo(e),l){if(i.then(Sr,Sr),t)return i.then(c=>{xr(e,c)}).catch(c=>{qn(c,e,0)});e.asyncDep=i}else xr(e,i)}else Ri(e)}function xr(e,t,n){K(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:ne(t)&&(e.setupState=Do(t)),Ri(e)}function Ri(e,t,n){const s=e.type;e.render||(e.render=s.render||qe);{const r=_n(e);st();try{ec(e)}finally{rt(),r()}}}const Vc={get(e,t){return ge(e,"get",""),e[t]}};function Bc(e){const t=n=>{e.exposed=n||{}};return{attrs:new Proxy(e.attrs,Vc),slots:e.slots,emit:e.emit,expose:t}}function Xn(e){return e.exposed?e.exposeProxy||(e.exposeProxy=new Proxy(Do(Gs(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in Yt)return Yt[n](e)},has(t,n){return n in t||n in Yt}})):e.proxy}function Kc(e,t=!0){return K(e)?e.displayName||e.name:e.name||t&&e.__name}function Uc(e){return K(e)&&"__vccOpts"in e}const Me=(e,t)=>Il(e,t,fn);function Zs(e,t,n){try{Dn(-1);const s=arguments.length;return s===2?ne(t)&&!D(t)?$n(t)?we(e,null,[t]):we(e,t):we(e,null,t):(s>3?n=Array.prototype.slice.call(arguments,2):s===3&&$n(n)&&(n=[n]),we(e,t,n))}finally{Dn(1)}}const Wc="3.5.22";/**
-* @vue/runtime-dom v3.5.22
-* (c) 2018-present Yuxi (Evan) You and Vue contributors
-* @license MIT
-**/let As;const Er=typeof window<"u"&&window.trustedTypes;if(Er)try{As=Er.createPolicy("vue",{createHTML:e=>e})}catch{}const Ai=As?e=>As.createHTML(e):e=>e,qc="http://www.w3.org/2000/svg",Gc="http://www.w3.org/1998/Math/MathML",Xe=typeof document<"u"?document:null,wr=Xe&&Xe.createElement("template"),zc={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{const t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,s)=>{const r=t==="svg"?Xe.createElementNS(qc,e):t==="mathml"?Xe.createElementNS(Gc,e):n?Xe.createElement(e,{is:n}):Xe.createElement(e);return e==="select"&&s&&s.multiple!=null&&r.setAttribute("multiple",s.multiple),r},createText:e=>Xe.createTextNode(e),createComment:e=>Xe.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>Xe.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,s,r,o){const i=n?n.previousSibling:t.lastChild;if(r&&(r===o||r.nextSibling))for(;t.insertBefore(r.cloneNode(!0),n),!(r===o||!(r=r.nextSibling)););else{wr.innerHTML=Ai(s==="svg"?`<svg>${e}</svg>`:s==="mathml"?`<math>${e}</math>`:e);const l=wr.content;if(s==="svg"||s==="mathml"){const c=l.firstChild;for(;c.firstChild;)l.appendChild(c.firstChild);l.removeChild(c)}t.insertBefore(l,n)}return[i?i.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},lt="transition",Kt="animation",un=Symbol("_vtc"),Pi={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Jc=de({},Wo,Pi),Qc=e=>(e.displayName="Transition",e.props=Jc,e),Hu=Qc((e,{slots:t})=>Zs(Bl,Yc(e),t)),St=(e,t=[])=>{D(e)?e.forEach(n=>n(...t)):e&&e(...t)},Cr=e=>e?D(e)?e.some(t=>t.length>1):e.length>1:!1;function Yc(e){const t={};for(const P in e)P in Pi||(t[P]=e[P]);if(e.css===!1)return t;const{name:n="v",type:s,duration:r,enterFromClass:o=`${n}-enter-from`,enterActiveClass:i=`${n}-enter-active`,enterToClass:l=`${n}-enter-to`,appearFromClass:c=o,appearActiveClass:a=i,appearToClass:f=l,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,x=Xc(r),A=x&&x[0],k=x&&x[1],{onBeforeEnter:N,onEnter:I,onEnterCancelled:F,onLeave:L,onLeaveCancelled:V,onBeforeAppear:se=N,onAppear:G=I,onAppearCancelled:W=F}=t,T=(P,z,ae,ye)=>{P._enterCancelled=ye,xt(P,z?f:l),xt(P,z?a:i),ae&&ae()},U=(P,z)=>{P._isLeaving=!1,xt(P,d),xt(P,m),xt(P,p),z&&z()},Q=P=>(z,ae)=>{const ye=P?G:I,re=()=>T(z,P,ae);St(ye,[z,re]),Rr(()=>{xt(z,P?c:o),Qe(z,P?f:l),Cr(ye)||Ar(z,s,A,re)})};return de(t,{onBeforeEnter(P){St(N,[P]),Qe(P,o),Qe(P,i)},onBeforeAppear(P){St(se,[P]),Qe(P,c),Qe(P,a)},onEnter:Q(!1),onAppear:Q(!0),onLeave(P,z){P._isLeaving=!0;const ae=()=>U(P,z);Qe(P,d),P._enterCancelled?(Qe(P,p),Or(P)):(Or(P),Qe(P,p)),Rr(()=>{P._isLeaving&&(xt(P,d),Qe(P,m),Cr(L)||Ar(P,s,k,ae))}),St(L,[P,ae])},onEnterCancelled(P){T(P,!1,void 0,!0),St(F,[P])},onAppearCancelled(P){T(P,!0,void 0,!0),St(W,[P])},onLeaveCancelled(P){U(P),St(V,[P])}})}function Xc(e){if(e==null)return null;if(ne(e))return[us(e.enter),us(e.leave)];{const t=us(e);return[t,t]}}function us(e){return Qi(e)}function Qe(e,t){t.split(/\s+/).forEach(n=>n&&e.classList.add(n)),(e[un]||(e[un]=new Set)).add(t)}function xt(e,t){t.split(/\s+/).forEach(s=>s&&e.classList.remove(s));const n=e[un];n&&(n.delete(t),n.size||(e[un]=void 0))}function Rr(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let Zc=0;function Ar(e,t,n,s){const r=e._endId=++Zc,o=()=>{r===e._endId&&s()};if(n!=null)return setTimeout(o,n);const{type:i,timeout:l,propCount:c}=ef(e,t);if(!i)return s();const a=i+"end";let f=0;const d=()=>{e.removeEventListener(a,p),o()},p=m=>{m.target===e&&++f>=c&&d()};setTimeout(()=>{f<c&&d()},l+1),e.addEventListener(a,p)}function ef(e,t){const n=window.getComputedStyle(e),s=x=>(n[x]||"").split(", "),r=s(`${lt}Delay`),o=s(`${lt}Duration`),i=Pr(r,o),l=s(`${Kt}Delay`),c=s(`${Kt}Duration`),a=Pr(l,c);let f=null,d=0,p=0;t===lt?i>0&&(f=lt,d=i,p=o.length):t===Kt?a>0&&(f=Kt,d=a,p=c.length):(d=Math.max(i,a),f=d>0?i>a?lt:Kt:null,p=f?f===lt?o.length:c.length:0);const m=f===lt&&/\b(?:transform|all)(?:,|$)/.test(s(`${lt}Property`).toString());return{type:f,timeout:d,propCount:p,hasTransform:m}}function Pr(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((n,s)=>Tr(n)+Tr(e[s])))}function Tr(e){return e==="auto"?0:Number(e.slice(0,-1).replace(",","."))*1e3}function Or(e){return(e?e.ownerDocument:document).body.offsetHeight}function tf(e,t,n){const s=e[un];s&&(t=(t?[t,...s]:[...s]).join(" ")),t==null?e.removeAttribute("class"):n?e.setAttribute("class",t):e.className=t}const Mr=Symbol("_vod"),nf=Symbol("_vsh"),sf=Symbol(""),rf=/(?:^|;)\s*display\s*:/;function of(e,t,n){const s=e.style,r=ue(n);let o=!1;if(n&&!r){if(t)if(ue(t))for(const i of t.split(";")){const l=i.slice(0,i.indexOf(":")).trim();n[l]==null&&Pn(s,l,"")}else for(const i in t)n[i]==null&&Pn(s,i,"");for(const i in n)i==="display"&&(o=!0),Pn(s,i,n[i])}else if(r){if(t!==n){const i=s[sf];i&&(n+=";"+i),s.cssText=n,o=rf.test(n)}}else t&&e.removeAttribute("style");Mr in e&&(e[Mr]=o?s.display:"",e[nf]&&(s.display="none"))}const Ir=/\s*!important$/;function Pn(e,t,n){if(D(n))n.forEach(s=>Pn(e,t,s));else if(n==null&&(n=""),t.startsWith("--"))e.setProperty(t,n);else{const s=lf(e,t);Ir.test(n)?e.setProperty(_t(s),n.replace(Ir,""),"important"):e[s]=n}}const Lr=["Webkit","Moz","ms"],as={};function lf(e,t){const n=as[t];if(n)return n;let s=Ne(t);if(s!=="filter"&&s in e)return as[t]=s;s=Bn(s);for(let r=0;r<Lr.length;r++){const o=Lr[r]+s;if(o in e)return as[t]=o}return t}const Nr="http://www.w3.org/1999/xlink";function Fr(e,t,n,s,r,o=nl(t)){s&&t.startsWith("xlink:")?n==null?e.removeAttributeNS(Nr,t.slice(6,t.length)):e.setAttributeNS(Nr,t,n):n==null||o&&!go(n)?e.removeAttribute(t):e.setAttribute(t,o?"":Ge(n)?String(n):n)}function jr(e,t,n,s,r){if(t==="innerHTML"||t==="textContent"){n!=null&&(e[t]=t==="innerHTML"?Ai(n):n);return}const o=e.tagName;if(t==="value"&&o!=="PROGRESS"&&!o.includes("-")){const l=o==="OPTION"?e.getAttribute("value")||"":e.value,c=n==null?e.type==="checkbox"?"on":"":String(n);(l!==c||!("_value"in e))&&(e.value=c),n==null&&e.removeAttribute(t),e._value=n;return}let i=!1;if(n===""||n==null){const l=typeof e[t];l==="boolean"?n=go(n):n==null&&l==="string"?(n="",i=!0):l==="number"&&(n=0,i=!0)}try{e[t]=n}catch{}i&&e.removeAttribute(r||t)}function ht(e,t,n,s){e.addEventListener(t,n,s)}function cf(e,t,n,s){e.removeEventListener(t,n,s)}const Dr=Symbol("_vei");function ff(e,t,n,s,r=null){const o=e[Dr]||(e[Dr]={}),i=o[t];if(s&&i)i.value=s;else{const[l,c]=uf(t);if(s){const a=o[t]=hf(s,r);ht(e,l,a,c)}else i&&(cf(e,l,i,c),o[t]=void 0)}}const $r=/(?:Once|Passive|Capture)$/;function uf(e){let t;if($r.test(e)){t={};let s;for(;s=e.match($r);)e=e.slice(0,e.length-s[0].length),t[s[0].toLowerCase()]=!0}return[e[2]===":"?e.slice(3):_t(e.slice(2)),t]}let ds=0;const af=Promise.resolve(),df=()=>ds||(af.then(()=>ds=0),ds=Date.now());function hf(e,t){const n=s=>{if(!s._vts)s._vts=Date.now();else if(s._vts<=n.attached)return;je(pf(s,n.value),t,5,[s])};return n.value=e,n.attached=df(),n}function pf(e,t){if(D(t)){const n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(s=>r=>!r._stopped&&s&&s(r))}else return t}const Hr=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,gf=(e,t,n,s,r,o)=>{const i=r==="svg";t==="class"?tf(e,s,i):t==="style"?of(e,n,s):kn(t)?Ns(t)||ff(e,t,n,s,o):(t[0]==="."?(t=t.slice(1),!0):t[0]==="^"?(t=t.slice(1),!1):mf(e,t,s,i))?(jr(e,t,s),!e.tagName.includes("-")&&(t==="value"||t==="checked"||t==="selected")&&Fr(e,t,s,i,o,t!=="value")):e._isVueCE&&(/[A-Z]/.test(t)||!ue(s))?jr(e,Ne(t),s,o,t):(t==="true-value"?e._trueValue=s:t==="false-value"&&(e._falseValue=s),Fr(e,t,s,i))};function mf(e,t,n,s){if(s)return!!(t==="innerHTML"||t==="textContent"||t in e&&Hr(t)&&K(n));if(t==="spellcheck"||t==="draggable"||t==="translate"||t==="autocorrect"||t==="form"||t==="list"&&e.tagName==="INPUT"||t==="type"&&e.tagName==="TEXTAREA")return!1;if(t==="width"||t==="height"){const r=e.tagName;if(r==="IMG"||r==="VIDEO"||r==="CANVAS"||r==="SOURCE")return!1}return Hr(t)&&ue(n)?!1:t in e}const Dt=e=>{const t=e.props["onUpdate:modelValue"]||!1;return D(t)?n=>wn(t,n):t};function yf(e){e.target.composing=!0}function kr(e){const t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event("input")))}const nt=Symbol("_assign"),ku={created(e,{modifiers:{lazy:t,trim:n,number:s}},r){e[nt]=Dt(r);const o=s||r.props&&r.props.type==="number";ht(e,t?"change":"input",i=>{if(i.target.composing)return;let l=e.value;n&&(l=l.trim()),o&&(l=Tn(l)),e[nt](l)}),n&&ht(e,"change",()=>{e.value=e.value.trim()}),t||(ht(e,"compositionstart",yf),ht(e,"compositionend",kr),ht(e,"change",kr))},mounted(e,{value:t}){e.value=t??""},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:s,trim:r,number:o}},i){if(e[nt]=Dt(i),e.composing)return;const l=(o||e.type==="number")&&!/^0\d/.test(e.value)?Tn(e.value):e.value,c=t??"";l!==c&&(document.activeElement===e&&e.type!=="range"&&(s&&t===n||r&&e.value.trim()===c)||(e.value=c))}},Vu={deep:!0,created(e,t,n){e[nt]=Dt(n),ht(e,"change",()=>{const s=e._modelValue,r=an(e),o=e.checked,i=e[nt];if(D(s)){const l=Hs(s,r),c=l!==-1;if(o&&!c)i(s.concat(r));else if(!o&&c){const a=[...s];a.splice(l,1),i(a)}}else if(kt(s)){const l=new Set(s);o?l.add(r):l.delete(r),i(l)}else i(Ti(e,o))})},mounted:Vr,beforeUpdate(e,t,n){e[nt]=Dt(n),Vr(e,t,n)}};function Vr(e,{value:t,oldValue:n},s){e._modelValue=t;let r;if(D(t))r=Hs(t,s.props.value)>-1;else if(kt(t))r=t.has(s.props.value);else{if(t===n)return;r=gn(t,Ti(e,!0))}e.checked!==r&&(e.checked=r)}const Bu={deep:!0,created(e,{value:t,modifiers:{number:n}},s){const r=kt(t);ht(e,"change",()=>{const o=Array.prototype.filter.call(e.options,i=>i.selected).map(i=>n?Tn(an(i)):an(i));e[nt](e.multiple?r?new Set(o):o:o[0]),e._assigning=!0,Gn(()=>{e._assigning=!1})}),e[nt]=Dt(s)},mounted(e,{value:t}){Br(e,t)},beforeUpdate(e,t,n){e[nt]=Dt(n)},updated(e,{value:t}){e._assigning||Br(e,t)}};function Br(e,t){const n=e.multiple,s=D(t);if(!(n&&!s&&!kt(t))){for(let r=0,o=e.options.length;r<o;r++){const i=e.options[r],l=an(i);if(n)if(s){const c=typeof l;c==="string"||c==="number"?i.selected=t.some(a=>String(a)===String(l)):i.selected=Hs(t,l)>-1}else i.selected=t.has(l);else if(gn(an(i),t)){e.selectedIndex!==r&&(e.selectedIndex=r);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function an(e){return"_value"in e?e._value:e.value}function Ti(e,t){const n=t?"_trueValue":"_falseValue";return n in e?e[n]:t}const _f=["ctrl","shift","alt","meta"],vf={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>"button"in e&&e.button!==0,middle:e=>"button"in e&&e.button!==1,right:e=>"button"in e&&e.button!==2,exact:(e,t)=>_f.some(n=>e[`${n}Key`]&&!t.includes(n))},Ku=(e,t)=>{const n=e._withMods||(e._withMods={}),s=t.join(".");return n[s]||(n[s]=(r,...o)=>{for(let i=0;i<t.length;i++){const l=vf[t[i]];if(l&&l(r,t))return}return e(r,...o)})},bf={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},Uu=(e,t)=>{const n=e._withKeys||(e._withKeys={}),s=t.join(".");return n[s]||(n[s]=r=>{if(!("key"in r))return;const o=_t(r.key);if(t.some(i=>i===o||bf[i]===o))return e(r)})},Sf=de({patchProp:gf},zc);let Kr;function xf(){return Kr||(Kr=pc(Sf))}const Wu=(...e)=>{const t=xf().createApp(...e),{mount:n}=t;return t.mount=s=>{const r=wf(s);if(!r)return;const o=t._component;!K(o)&&!o.render&&!o.template&&(o.template=r.innerHTML),r.nodeType===1&&(r.textContent="");const i=n(r,!1,Ef(r));return r instanceof Element&&(r.removeAttribute("v-cloak"),r.setAttribute("data-v-app","")),i},t};function Ef(e){if(e instanceof SVGElement)return"svg";if(typeof MathMLElement=="function"&&e instanceof MathMLElement)return"mathml"}function wf(e){return ue(e)?document.querySelector(e):e}/*!
- * pinia v2.3.1
- * (c) 2025 Eduardo San Martin Morote
- * @license MIT
- */let Oi;const Zn=e=>Oi=e,Mi=Symbol();function Ps(e){return e&&typeof e=="object"&&Object.prototype.toString.call(e)==="[object Object]"&&typeof e.toJSON!="function"}var en;(function(e){e.direct="direct",e.patchObject="patch object",e.patchFunction="patch function"})(en||(en={}));function qu(){const e=vo(!0),t=e.run(()=>Wn({}));let n=[],s=[];const r=Gs({install(o){Zn(r),r._a=o,o.provide(Mi,r),o.config.globalProperties.$pinia=r,s.forEach(i=>n.push(i)),s=[]},use(o){return this._a?n.push(o):s.push(o),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return r}const Ii=()=>{};function Ur(e,t,n,s=Ii){e.push(t);const r=()=>{const o=e.indexOf(t);o>-1&&(e.splice(o,1),s())};return!n&&bo()&&ol(r),r}function Ot(e,...t){e.slice().forEach(n=>{n(...t)})}const Cf=e=>e(),Wr=Symbol(),hs=Symbol();function Ts(e,t){e instanceof Map&&t instanceof Map?t.forEach((n,s)=>e.set(s,n)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(const n in t){if(!t.hasOwnProperty(n))continue;const s=t[n],r=e[n];Ps(r)&&Ps(s)&&e.hasOwnProperty(n)&&!fe(s)&&!gt(s)?e[n]=Ts(r,s):e[n]=s}return e}const Rf=Symbol();function Af(e){return!Ps(e)||!e.hasOwnProperty(Rf)}const{assign:ft}=Object;function Pf(e){return!!(fe(e)&&e.effect)}function Tf(e,t,n,s){const{state:r,actions:o,getters:i}=t,l=n.state.value[e];let c;function a(){l||(n.state.value[e]=r?r():{});const f=Pl(n.state.value[e]);return ft(f,o,Object.keys(i||{}).reduce((d,p)=>(d[p]=Gs(Me(()=>{Zn(n);const m=n._s.get(e);return i[p].call(m,m)})),d),{}))}return c=Li(e,a,t,n,s,!0),c}function Li(e,t,n={},s,r,o){let i;const l=ft({actions:{}},n),c={deep:!0};let a,f,d=[],p=[],m;const x=s.state.value[e];!o&&!x&&(s.state.value[e]={}),Wn({});let A;function k(W){let T;a=f=!1,typeof W=="function"?(W(s.state.value[e]),T={type:en.patchFunction,storeId:e,events:m}):(Ts(s.state.value[e],W),T={type:en.patchObject,payload:W,storeId:e,events:m});const U=A=Symbol();Gn().then(()=>{A===U&&(a=!0)}),f=!0,Ot(d,T,s.state.value[e])}const N=o?function(){const{state:T}=n,U=T?T():{};this.$patch(Q=>{ft(Q,U)})}:Ii;function I(){i.stop(),d=[],p=[],s._s.delete(e)}const F=(W,T="")=>{if(Wr in W)return W[hs]=T,W;const U=function(){Zn(s);const Q=Array.from(arguments),P=[],z=[];function ae(q){P.push(q)}function ye(q){z.push(q)}Ot(p,{args:Q,name:U[hs],store:V,after:ae,onError:ye});let re;try{re=W.apply(this&&this.$id===e?this:V,Q)}catch(q){throw Ot(z,q),q}return re instanceof Promise?re.then(q=>(Ot(P,q),q)).catch(q=>(Ot(z,q),Promise.reject(q))):(Ot(P,re),re)};return U[Wr]=!0,U[hs]=T,U},L={_p:s,$id:e,$onAction:Ur.bind(null,p),$patch:k,$reset:N,$subscribe(W,T={}){const U=Ur(d,W,T.detached,()=>Q()),Q=i.run(()=>Xt(()=>s.state.value[e],P=>{(T.flush==="sync"?f:a)&&W({storeId:e,type:en.direct,events:m},P)},ft({},c,T)));return U},$dispose:I},V=mn(L);s._s.set(e,V);const G=(s._a&&s._a.runWithContext||Cf)(()=>s._e.run(()=>(i=vo()).run(()=>t({action:F}))));for(const W in G){const T=G[W];if(fe(T)&&!Pf(T)||gt(T))o||(x&&Af(T)&&(fe(T)?T.value=x[W]:Ts(T,x[W])),s.state.value[e][W]=T);else if(typeof T=="function"){const U=F(T,W);G[W]=U,l.actions[W]=T}}return ft(V,G),ft(Y(V),G),Object.defineProperty(V,"$state",{get:()=>s.state.value[e],set:W=>{k(T=>{ft(T,W)})}}),s._p.forEach(W=>{ft(V,i.run(()=>W({store:V,app:s._a,pinia:s,options:l})))}),x&&o&&n.hydrate&&n.hydrate(V.$state,x),a=!0,f=!0,V}/*! #__NO_SIDE_EFFECTS__ */function Gu(e,t,n){let s,r;const o=typeof t=="function";s=e,r=o?n:t;function i(l,c){const a=lc();return l=l||(a?Le(Mi,null):null),l&&Zn(l),l=Oi,l._s.has(s)||(o?Li(s,t,r,l):Tf(s,r,l)),l._s.get(s)}return i.$id=s,i}/*!
-  * vue-router v4.5.1
-  * (c) 2025 Eduardo San Martin Morote
-  * @license MIT
-  */const It=typeof document<"u";function Ni(e){return typeof e=="object"||"displayName"in e||"props"in e||"__vccOpts"in e}function Of(e){return e.__esModule||e[Symbol.toStringTag]==="Module"||e.default&&Ni(e.default)}const Z=Object.assign;function ps(e,t){const n={};for(const s in t){const r=t[s];n[s]=De(r)?r.map(e):e(r)}return n}const tn=()=>{},De=Array.isArray,Fi=/#/g,Mf=/&/g,If=/\//g,Lf=/=/g,Nf=/\?/g,ji=/\+/g,Ff=/%5B/g,jf=/%5D/g,Di=/%5E/g,Df=/%60/g,$i=/%7B/g,$f=/%7C/g,Hi=/%7D/g,Hf=/%20/g;function er(e){return encodeURI(""+e).replace($f,"|").replace(Ff,"[").replace(jf,"]")}function kf(e){return er(e).replace($i,"{").replace(Hi,"}").replace(Di,"^")}function Os(e){return er(e).replace(ji,"%2B").replace(Hf,"+").replace(Fi,"%23").replace(Mf,"%26").replace(Df,"`").replace($i,"{").replace(Hi,"}").replace(Di,"^")}function Vf(e){return Os(e).replace(Lf,"%3D")}function Bf(e){return er(e).replace(Fi,"%23").replace(Nf,"%3F")}function Kf(e){return e==null?"":Bf(e).replace(If,"%2F")}function dn(e){try{return decodeURIComponent(""+e)}catch{}return""+e}const Uf=/\/$/,Wf=e=>e.replace(Uf,"");function gs(e,t,n="/"){let s,r={},o="",i="";const l=t.indexOf("#");let c=t.indexOf("?");return l<c&&l>=0&&(c=-1),c>-1&&(s=t.slice(0,c),o=t.slice(c+1,l>-1?l:t.length),r=e(o)),l>-1&&(s=s||t.slice(0,l),i=t.slice(l,t.length)),s=Jf(s??t,n),{fullPath:s+(o&&"?")+o+i,path:s,query:r,hash:dn(i)}}function qf(e,t){const n=t.query?e(t.query):"";return t.path+(n&&"?")+n+(t.hash||"")}function qr(e,t){return!t||!e.toLowerCase().startsWith(t.toLowerCase())?e:e.slice(t.length)||"/"}function Gf(e,t,n){const s=t.matched.length-1,r=n.matched.length-1;return s>-1&&s===r&&$t(t.matched[s],n.matched[r])&&ki(t.params,n.params)&&e(t.query)===e(n.query)&&t.hash===n.hash}function $t(e,t){return(e.aliasOf||e)===(t.aliasOf||t)}function ki(e,t){if(Object.keys(e).length!==Object.keys(t).length)return!1;for(const n in e)if(!zf(e[n],t[n]))return!1;return!0}function zf(e,t){return De(e)?Gr(e,t):De(t)?Gr(t,e):e===t}function Gr(e,t){return De(t)?e.length===t.length&&e.every((n,s)=>n===t[s]):e.length===1&&e[0]===t}function Jf(e,t){if(e.startsWith("/"))return e;if(!e)return t;const n=t.split("/"),s=e.split("/"),r=s[s.length-1];(r===".."||r===".")&&s.push("");let o=n.length-1,i,l;for(i=0;i<s.length;i++)if(l=s[i],l!==".")if(l==="..")o>1&&o--;else break;return n.slice(0,o).join("/")+"/"+s.slice(i).join("/")}const ct={path:"/",name:void 0,params:{},query:{},hash:"",fullPath:"/",matched:[],meta:{},redirectedFrom:void 0};var hn;(function(e){e.pop="pop",e.push="push"})(hn||(hn={}));var nn;(function(e){e.back="back",e.forward="forward",e.unknown=""})(nn||(nn={}));function Qf(e){if(!e)if(It){const t=document.querySelector("base");e=t&&t.getAttribute("href")||"/",e=e.replace(/^\w+:\/\/[^\/]+/,"")}else e="/";return e[0]!=="/"&&e[0]!=="#"&&(e="/"+e),Wf(e)}const Yf=/^[^#]+#/;function Xf(e,t){return e.replace(Yf,"#")+t}function Zf(e,t){const n=document.documentElement.getBoundingClientRect(),s=e.getBoundingClientRect();return{behavior:t.behavior,left:s.left-n.left-(t.left||0),top:s.top-n.top-(t.top||0)}}const es=()=>({left:window.scrollX,top:window.scrollY});function eu(e){let t;if("el"in e){const n=e.el,s=typeof n=="string"&&n.startsWith("#"),r=typeof n=="string"?s?document.getElementById(n.slice(1)):document.querySelector(n):n;if(!r)return;t=Zf(r,e)}else t=e;"scrollBehavior"in document.documentElement.style?window.scrollTo(t):window.scrollTo(t.left!=null?t.left:window.scrollX,t.top!=null?t.top:window.scrollY)}function zr(e,t){return(history.state?history.state.position-t:-1)+e}const Ms=new Map;function tu(e,t){Ms.set(e,t)}function nu(e){const t=Ms.get(e);return Ms.delete(e),t}let su=()=>location.protocol+"//"+location.host;function Vi(e,t){const{pathname:n,search:s,hash:r}=t,o=e.indexOf("#");if(o>-1){let l=r.includes(e.slice(o))?e.slice(o).length:1,c=r.slice(l);return c[0]!=="/"&&(c="/"+c),qr(c,"")}return qr(n,e)+s+r}function ru(e,t,n,s){let r=[],o=[],i=null;const l=({state:p})=>{const m=Vi(e,location),x=n.value,A=t.value;let k=0;if(p){if(n.value=m,t.value=p,i&&i===x){i=null;return}k=A?p.position-A.position:0}else s(m);r.forEach(N=>{N(n.value,x,{delta:k,type:hn.pop,direction:k?k>0?nn.forward:nn.back:nn.unknown})})};function c(){i=n.value}function a(p){r.push(p);const m=()=>{const x=r.indexOf(p);x>-1&&r.splice(x,1)};return o.push(m),m}function f(){const{history:p}=window;p.state&&p.replaceState(Z({},p.state,{scroll:es()}),"")}function d(){for(const p of o)p();o=[],window.removeEventListener("popstate",l),window.removeEventListener("beforeunload",f)}return window.addEventListener("popstate",l),window.addEventListener("beforeunload",f,{passive:!0}),{pauseListeners:c,listen:a,destroy:d}}function Jr(e,t,n,s=!1,r=!1){return{back:e,current:t,forward:n,replaced:s,position:window.history.length,scroll:r?es():null}}function ou(e){const{history:t,location:n}=window,s={value:Vi(e,n)},r={value:t.state};r.value||o(s.value,{back:null,current:s.value,forward:null,position:t.length-1,replaced:!0,scroll:null},!0);function o(c,a,f){const d=e.indexOf("#"),p=d>-1?(n.host&&document.querySelector("base")?e:e.slice(d))+c:su()+e+c;try{t[f?"replaceState":"pushState"](a,"",p),r.value=a}catch(m){console.error(m),n[f?"replace":"assign"](p)}}function i(c,a){const f=Z({},t.state,Jr(r.value.back,c,r.value.forward,!0),a,{position:r.value.position});o(c,f,!0),s.value=c}function l(c,a){const f=Z({},r.value,t.state,{forward:c,scroll:es()});o(f.current,f,!0);const d=Z({},Jr(s.value,c,null),{position:f.position+1},a);o(c,d,!1),s.value=c}return{location:s,state:r,push:l,replace:i}}function zu(e){e=Qf(e);const t=ou(e),n=ru(e,t.state,t.location,t.replace);function s(o,i=!0){i||n.pauseListeners(),history.go(o)}const r=Z({location:"",base:e,go:s,createHref:Xf.bind(null,e)},t,n);return Object.defineProperty(r,"location",{enumerable:!0,get:()=>t.location.value}),Object.defineProperty(r,"state",{enumerable:!0,get:()=>t.state.value}),r}function iu(e){return typeof e=="string"||e&&typeof e=="object"}function Bi(e){return typeof e=="string"||typeof e=="symbol"}const Ki=Symbol("");var Qr;(function(e){e[e.aborted=4]="aborted",e[e.cancelled=8]="cancelled",e[e.duplicated=16]="duplicated"})(Qr||(Qr={}));function Ht(e,t){return Z(new Error,{type:e,[Ki]:!0},t)}function Ye(e,t){return e instanceof Error&&Ki in e&&(t==null||!!(e.type&t))}const Yr="[^/]+?",lu={sensitive:!1,strict:!1,start:!0,end:!0},cu=/[.+*?^${}()[\]/\\]/g;function fu(e,t){const n=Z({},lu,t),s=[];let r=n.start?"^":"";const o=[];for(const a of e){const f=a.length?[]:[90];n.strict&&!a.length&&(r+="/");for(let d=0;d<a.length;d++){const p=a[d];let m=40+(n.sensitive?.25:0);if(p.type===0)d||(r+="/"),r+=p.value.replace(cu,"\\$&"),m+=40;else if(p.type===1){const{value:x,repeatable:A,optional:k,regexp:N}=p;o.push({name:x,repeatable:A,optional:k});const I=N||Yr;if(I!==Yr){m+=10;try{new RegExp(`(${I})`)}catch(L){throw new Error(`Invalid custom RegExp for param "${x}" (${I}): `+L.message)}}let F=A?`((?:${I})(?:/(?:${I}))*)`:`(${I})`;d||(F=k&&a.length<2?`(?:/${F})`:"/"+F),k&&(F+="?"),r+=F,m+=20,k&&(m+=-8),A&&(m+=-20),I===".*"&&(m+=-50)}f.push(m)}s.push(f)}if(n.strict&&n.end){const a=s.length-1;s[a][s[a].length-1]+=.7000000000000001}n.strict||(r+="/?"),n.end?r+="$":n.strict&&!r.endsWith("/")&&(r+="(?:/|$)");const i=new RegExp(r,n.sensitive?"":"i");function l(a){const f=a.match(i),d={};if(!f)return null;for(let p=1;p<f.length;p++){const m=f[p]||"",x=o[p-1];d[x.name]=m&&x.repeatable?m.split("/"):m}return d}function c(a){let f="",d=!1;for(const p of e){(!d||!f.endsWith("/"))&&(f+="/"),d=!1;for(const m of p)if(m.type===0)f+=m.value;else if(m.type===1){const{value:x,repeatable:A,optional:k}=m,N=x in a?a[x]:"";if(De(N)&&!A)throw new Error(`Provided param "${x}" is an array but it is not repeatable (* or + modifiers)`);const I=De(N)?N.join("/"):N;if(!I)if(k)p.length<2&&(f.endsWith("/")?f=f.slice(0,-1):d=!0);else throw new Error(`Missing required param "${x}"`);f+=I}}return f||"/"}return{re:i,score:s,keys:o,parse:l,stringify:c}}function uu(e,t){let n=0;for(;n<e.length&&n<t.length;){const s=t[n]-e[n];if(s)return s;n++}return e.length<t.length?e.length===1&&e[0]===80?-1:1:e.length>t.length?t.length===1&&t[0]===80?1:-1:0}function Ui(e,t){let n=0;const s=e.score,r=t.score;for(;n<s.length&&n<r.length;){const o=uu(s[n],r[n]);if(o)return o;n++}if(Math.abs(r.length-s.length)===1){if(Xr(s))return 1;if(Xr(r))return-1}return r.length-s.length}function Xr(e){const t=e[e.length-1];return e.length>0&&t[t.length-1]<0}const au={type:0,value:""},du=/[a-zA-Z0-9_]/;function hu(e){if(!e)return[[]];if(e==="/")return[[au]];if(!e.startsWith("/"))throw new Error(`Invalid path "${e}"`);function t(m){throw new Error(`ERR (${n})/"${a}": ${m}`)}let n=0,s=n;const r=[];let o;function i(){o&&r.push(o),o=[]}let l=0,c,a="",f="";function d(){a&&(n===0?o.push({type:0,value:a}):n===1||n===2||n===3?(o.length>1&&(c==="*"||c==="+")&&t(`A repeatable param (${a}) must be alone in its segment. eg: '/:ids+.`),o.push({type:1,value:a,regexp:f,repeatable:c==="*"||c==="+",optional:c==="*"||c==="?"})):t("Invalid state to consume buffer"),a="")}function p(){a+=c}for(;l<e.length;){if(c=e[l++],c==="\\"&&n!==2){s=n,n=4;continue}switch(n){case 0:c==="/"?(a&&d(),i()):c===":"?(d(),n=1):p();break;case 4:p(),n=s;break;case 1:c==="("?n=2:du.test(c)?p():(d(),n=0,c!=="*"&&c!=="?"&&c!=="+"&&l--);break;case 2:c===")"?f[f.length-1]=="\\"?f=f.slice(0,-1)+c:n=3:f+=c;break;case 3:d(),n=0,c!=="*"&&c!=="?"&&c!=="+"&&l--,f="";break;default:t("Unknown state");break}}return n===2&&t(`Unfinished custom RegExp for param "${a}"`),d(),i(),r}function pu(e,t,n){const s=fu(hu(e.path),n),r=Z(s,{record:e,parent:t,children:[],alias:[]});return t&&!r.record.aliasOf==!t.record.aliasOf&&t.children.push(r),r}function gu(e,t){const n=[],s=new Map;t=no({strict:!1,end:!0,sensitive:!1},t);function r(d){return s.get(d)}function o(d,p,m){const x=!m,A=eo(d);A.aliasOf=m&&m.record;const k=no(t,d),N=[A];if("alias"in d){const L=typeof d.alias=="string"?[d.alias]:d.alias;for(const V of L)N.push(eo(Z({},A,{components:m?m.record.components:A.components,path:V,aliasOf:m?m.record:A})))}let I,F;for(const L of N){const{path:V}=L;if(p&&V[0]!=="/"){const se=p.record.path,G=se[se.length-1]==="/"?"":"/";L.path=p.record.path+(V&&G+V)}if(I=pu(L,p,k),m?m.alias.push(I):(F=F||I,F!==I&&F.alias.push(I),x&&d.name&&!to(I)&&i(d.name)),Wi(I)&&c(I),A.children){const se=A.children;for(let G=0;G<se.length;G++)o(se[G],I,m&&m.children[G])}m=m||I}return F?()=>{i(F)}:tn}function i(d){if(Bi(d)){const p=s.get(d);p&&(s.delete(d),n.splice(n.indexOf(p),1),p.children.forEach(i),p.alias.forEach(i))}else{const p=n.indexOf(d);p>-1&&(n.splice(p,1),d.record.name&&s.delete(d.record.name),d.children.forEach(i),d.alias.forEach(i))}}function l(){return n}function c(d){const p=_u(d,n);n.splice(p,0,d),d.record.name&&!to(d)&&s.set(d.record.name,d)}function a(d,p){let m,x={},A,k;if("name"in d&&d.name){if(m=s.get(d.name),!m)throw Ht(1,{location:d});k=m.record.name,x=Z(Zr(p.params,m.keys.filter(F=>!F.optional).concat(m.parent?m.parent.keys.filter(F=>F.optional):[]).map(F=>F.name)),d.params&&Zr(d.params,m.keys.map(F=>F.name))),A=m.stringify(x)}else if(d.path!=null)A=d.path,m=n.find(F=>F.re.test(A)),m&&(x=m.parse(A),k=m.record.name);else{if(m=p.name?s.get(p.name):n.find(F=>F.re.test(p.path)),!m)throw Ht(1,{location:d,currentLocation:p});k=m.record.name,x=Z({},p.params,d.params),A=m.stringify(x)}const N=[];let I=m;for(;I;)N.unshift(I.record),I=I.parent;return{name:k,path:A,params:x,matched:N,meta:yu(N)}}e.forEach(d=>o(d));function f(){n.length=0,s.clear()}return{addRoute:o,resolve:a,removeRoute:i,clearRoutes:f,getRoutes:l,getRecordMatcher:r}}function Zr(e,t){const n={};for(const s of t)s in e&&(n[s]=e[s]);return n}function eo(e){const t={path:e.path,redirect:e.redirect,name:e.name,meta:e.meta||{},aliasOf:e.aliasOf,beforeEnter:e.beforeEnter,props:mu(e),children:e.children||[],instances:{},leaveGuards:new Set,updateGuards:new Set,enterCallbacks:{},components:"components"in e?e.components||null:e.component&&{default:e.component}};return Object.defineProperty(t,"mods",{value:{}}),t}function mu(e){const t={},n=e.props||!1;if("component"in e)t.default=n;else for(const s in e.components)t[s]=typeof n=="object"?n[s]:n;return t}function to(e){for(;e;){if(e.record.aliasOf)return!0;e=e.parent}return!1}function yu(e){return e.reduce((t,n)=>Z(t,n.meta),{})}function no(e,t){const n={};for(const s in e)n[s]=s in t?t[s]:e[s];return n}function _u(e,t){let n=0,s=t.length;for(;n!==s;){const o=n+s>>1;Ui(e,t[o])<0?s=o:n=o+1}const r=vu(e);return r&&(s=t.lastIndexOf(r,s-1)),s}function vu(e){let t=e;for(;t=t.parent;)if(Wi(t)&&Ui(e,t)===0)return t}function Wi({record:e}){return!!(e.name||e.components&&Object.keys(e.components).length||e.redirect)}function bu(e){const t={};if(e===""||e==="?")return t;const s=(e[0]==="?"?e.slice(1):e).split("&");for(let r=0;r<s.length;++r){const o=s[r].replace(ji," "),i=o.indexOf("="),l=dn(i<0?o:o.slice(0,i)),c=i<0?null:dn(o.slice(i+1));if(l in t){let a=t[l];De(a)||(a=t[l]=[a]),a.push(c)}else t[l]=c}return t}function so(e){let t="";for(let n in e){const s=e[n];if(n=Vf(n),s==null){s!==void 0&&(t+=(t.length?"&":"")+n);continue}(De(s)?s.map(o=>o&&Os(o)):[s&&Os(s)]).forEach(o=>{o!==void 0&&(t+=(t.length?"&":"")+n,o!=null&&(t+="="+o))})}return t}function Su(e){const t={};for(const n in e){const s=e[n];s!==void 0&&(t[n]=De(s)?s.map(r=>r==null?null:""+r):s==null?s:""+s)}return t}const xu=Symbol(""),ro=Symbol(""),ts=Symbol(""),tr=Symbol(""),Is=Symbol("");function Ut(){let e=[];function t(s){return e.push(s),()=>{const r=e.indexOf(s);r>-1&&e.splice(r,1)}}function n(){e=[]}return{add:t,list:()=>e.slice(),reset:n}}function dt(e,t,n,s,r,o=i=>i()){const i=s&&(s.enterCallbacks[r]=s.enterCallbacks[r]||[]);return()=>new Promise((l,c)=>{const a=p=>{p===!1?c(Ht(4,{from:n,to:t})):p instanceof Error?c(p):iu(p)?c(Ht(2,{from:t,to:p})):(i&&s.enterCallbacks[r]===i&&typeof p=="function"&&i.push(p),l())},f=o(()=>e.call(s&&s.instances[r],t,n,a));let d=Promise.resolve(f);e.length<3&&(d=d.then(a)),d.catch(p=>c(p))})}function ms(e,t,n,s,r=o=>o()){const o=[];for(const i of e)for(const l in i.components){let c=i.components[l];if(!(t!=="beforeRouteEnter"&&!i.instances[l]))if(Ni(c)){const f=(c.__vccOpts||c)[t];f&&o.push(dt(f,n,s,i,l,r))}else{let a=c();o.push(()=>a.then(f=>{if(!f)throw new Error(`Couldn't resolve component "${l}" at "${i.path}"`);const d=Of(f)?f.default:f;i.mods[l]=f,i.components[l]=d;const m=(d.__vccOpts||d)[t];return m&&dt(m,n,s,i,l,r)()}))}}return o}function oo(e){const t=Le(ts),n=Le(tr),s=Me(()=>{const c=Ft(e.to);return t.resolve(c)}),r=Me(()=>{const{matched:c}=s.value,{length:a}=c,f=c[a-1],d=n.matched;if(!f||!d.length)return-1;const p=d.findIndex($t.bind(null,f));if(p>-1)return p;const m=io(c[a-2]);return a>1&&io(f)===m&&d[d.length-1].path!==m?d.findIndex($t.bind(null,c[a-2])):p}),o=Me(()=>r.value>-1&&Au(n.params,s.value.params)),i=Me(()=>r.value>-1&&r.value===n.matched.length-1&&ki(n.params,s.value.params));function l(c={}){if(Ru(c)){const a=t[Ft(e.replace)?"replace":"push"](Ft(e.to)).catch(tn);return e.viewTransition&&typeof document<"u"&&"startViewTransition"in document&&document.startViewTransition(()=>a),a}return Promise.resolve()}return{route:s,href:Me(()=>s.value.href),isActive:o,isExactActive:i,navigate:l}}function Eu(e){return e.length===1?e[0]:e}const wu=Qo({name:"RouterLink",compatConfig:{MODE:3},props:{to:{type:[String,Object],required:!0},replace:Boolean,activeClass:String,exactActiveClass:String,custom:Boolean,ariaCurrentValue:{type:String,default:"page"},viewTransition:Boolean},useLink:oo,setup(e,{slots:t}){const n=mn(oo(e)),{options:s}=Le(ts),r=Me(()=>({[lo(e.activeClass,s.linkActiveClass,"router-link-active")]:n.isActive,[lo(e.exactActiveClass,s.linkExactActiveClass,"router-link-exact-active")]:n.isExactActive}));return()=>{const o=t.default&&Eu(t.default(n));return e.custom?o:Zs("a",{"aria-current":n.isExactActive?e.ariaCurrentValue:null,href:n.href,onClick:n.navigate,class:r.value},o)}}}),Cu=wu;function Ru(e){if(!(e.metaKey||e.altKey||e.ctrlKey||e.shiftKey)&&!e.defaultPrevented&&!(e.button!==void 0&&e.button!==0)){if(e.currentTarget&&e.currentTarget.getAttribute){const t=e.currentTarget.getAttribute("target");if(/\b_blank\b/i.test(t))return}return e.preventDefault&&e.preventDefault(),!0}}function Au(e,t){for(const n in t){const s=t[n],r=e[n];if(typeof s=="string"){if(s!==r)return!1}else if(!De(r)||r.length!==s.length||s.some((o,i)=>o!==r[i]))return!1}return!0}function io(e){return e?e.aliasOf?e.aliasOf.path:e.path:""}const lo=(e,t,n)=>e??t??n,Pu=Qo({name:"RouterView",inheritAttrs:!1,props:{name:{type:String,default:"default"},route:Object},compatConfig:{MODE:3},setup(e,{attrs:t,slots:n}){const s=Le(Is),r=Me(()=>e.route||s.value),o=Le(ro,0),i=Me(()=>{let a=Ft(o);const{matched:f}=r.value;let d;for(;(d=f[a])&&!d.components;)a++;return a}),l=Me(()=>r.value.matched[i.value]);Cn(ro,Me(()=>i.value+1)),Cn(xu,l),Cn(Is,r);const c=Wn();return Xt(()=>[c.value,l.value,e.name],([a,f,d],[p,m,x])=>{f&&(f.instances[d]=a,m&&m!==f&&a&&a===p&&(f.leaveGuards.size||(f.leaveGuards=m.leaveGuards),f.updateGuards.size||(f.updateGuards=m.updateGuards))),a&&f&&(!m||!$t(f,m)||!p)&&(f.enterCallbacks[d]||[]).forEach(A=>A(a))},{flush:"post"}),()=>{const a=r.value,f=e.name,d=l.value,p=d&&d.components[f];if(!p)return co(n.default,{Component:p,route:a});const m=d.props[f],x=m?m===!0?a.params:typeof m=="function"?m(a):m:null,k=Zs(p,Z({},x,t,{onVnodeUnmounted:N=>{N.component.isUnmounted&&(d.instances[f]=null)},ref:c}));return co(n.default,{Component:k,route:a})||k}}});function co(e,t){if(!e)return null;const n=e(t);return n.length===1?n[0]:n}const Tu=Pu;function Ju(e){const t=gu(e.routes,e),n=e.parseQuery||bu,s=e.stringifyQuery||so,r=e.history,o=Ut(),i=Ut(),l=Ut(),c=Cl(ct);let a=ct;It&&e.scrollBehavior&&"scrollRestoration"in history&&(history.scrollRestoration="manual");const f=ps.bind(null,v=>""+v),d=ps.bind(null,Kf),p=ps.bind(null,dn);function m(v,M){let R,j;return Bi(v)?(R=t.getRecordMatcher(v),j=M):j=v,t.addRoute(j,R)}function x(v){const M=t.getRecordMatcher(v);M&&t.removeRoute(M)}function A(){return t.getRoutes().map(v=>v.record)}function k(v){return!!t.getRecordMatcher(v)}function N(v,M){if(M=Z({},M||c.value),typeof v=="string"){const g=gs(n,v,M.path),_=t.resolve({path:g.path},M),b=r.createHref(g.fullPath);return Z(g,_,{params:p(_.params),hash:dn(g.hash),redirectedFrom:void 0,href:b})}let R;if(v.path!=null)R=Z({},v,{path:gs(n,v.path,M.path).path});else{const g=Z({},v.params);for(const _ in g)g[_]==null&&delete g[_];R=Z({},v,{params:d(g)}),M.params=d(M.params)}const j=t.resolve(R,M),oe=v.hash||"";j.params=f(p(j.params));const u=qf(s,Z({},v,{hash:kf(oe),path:j.path})),h=r.createHref(u);return Z({fullPath:u,hash:oe,query:s===so?Su(v.query):v.query||{}},j,{redirectedFrom:void 0,href:h})}function I(v){return typeof v=="string"?gs(n,v,c.value.path):Z({},v)}function F(v,M){if(a!==v)return Ht(8,{from:M,to:v})}function L(v){return G(v)}function V(v){return L(Z(I(v),{replace:!0}))}function se(v){const M=v.matched[v.matched.length-1];if(M&&M.redirect){const{redirect:R}=M;let j=typeof R=="function"?R(v):R;return typeof j=="string"&&(j=j.includes("?")||j.includes("#")?j=I(j):{path:j},j.params={}),Z({query:v.query,hash:v.hash,params:j.path!=null?{}:v.params},j)}}function G(v,M){const R=a=N(v),j=c.value,oe=v.state,u=v.force,h=v.replace===!0,g=se(R);if(g)return G(Z(I(g),{state:typeof g=="object"?Z({},oe,g.state):oe,force:u,replace:h}),M||R);const _=R;_.redirectedFrom=M;let b;return!u&&Gf(s,j,R)&&(b=Ht(16,{to:_,from:j}),$e(j,j,!0,!1)),(b?Promise.resolve(b):U(_,j)).catch(y=>Ye(y)?Ye(y,2)?y:it(y):X(y,_,j)).then(y=>{if(y){if(Ye(y,2))return G(Z({replace:h},I(y.to),{state:typeof y.to=="object"?Z({},oe,y.to.state):oe,force:u}),M||_)}else y=P(_,j,!0,h,oe);return Q(_,j,y),y})}function W(v,M){const R=F(v,M);return R?Promise.reject(R):Promise.resolve()}function T(v){const M=Pt.values().next().value;return M&&typeof M.runWithContext=="function"?M.runWithContext(v):v()}function U(v,M){let R;const[j,oe,u]=Ou(v,M);R=ms(j.reverse(),"beforeRouteLeave",v,M);for(const g of j)g.leaveGuards.forEach(_=>{R.push(dt(_,v,M))});const h=W.bind(null,v,M);return R.push(h),Te(R).then(()=>{R=[];for(const g of o.list())R.push(dt(g,v,M));return R.push(h),Te(R)}).then(()=>{R=ms(oe,"beforeRouteUpdate",v,M);for(const g of oe)g.updateGuards.forEach(_=>{R.push(dt(_,v,M))});return R.push(h),Te(R)}).then(()=>{R=[];for(const g of u)if(g.beforeEnter)if(De(g.beforeEnter))for(const _ of g.beforeEnter)R.push(dt(_,v,M));else R.push(dt(g.beforeEnter,v,M));return R.push(h),Te(R)}).then(()=>(v.matched.forEach(g=>g.enterCallbacks={}),R=ms(u,"beforeRouteEnter",v,M,T),R.push(h),Te(R))).then(()=>{R=[];for(const g of i.list())R.push(dt(g,v,M));return R.push(h),Te(R)}).catch(g=>Ye(g,8)?g:Promise.reject(g))}function Q(v,M,R){l.list().forEach(j=>T(()=>j(v,M,R)))}function P(v,M,R,j,oe){const u=F(v,M);if(u)return u;const h=M===ct,g=It?history.state:{};R&&(j||h?r.replace(v.fullPath,Z({scroll:h&&g&&g.scroll},oe)):r.push(v.fullPath,oe)),c.value=v,$e(v,M,R,h),it()}let z;function ae(){z||(z=r.listen((v,M,R)=>{if(!vn.listening)return;const j=N(v),oe=se(j);if(oe){G(Z(oe,{replace:!0,force:!0}),j).catch(tn);return}a=j;const u=c.value;It&&tu(zr(u.fullPath,R.delta),es()),U(j,u).catch(h=>Ye(h,12)?h:Ye(h,2)?(G(Z(I(h.to),{force:!0}),j).then(g=>{Ye(g,20)&&!R.delta&&R.type===hn.pop&&r.go(-1,!1)}).catch(tn),Promise.reject()):(R.delta&&r.go(-R.delta,!1),X(h,j,u))).then(h=>{h=h||P(j,u,!1),h&&(R.delta&&!Ye(h,8)?r.go(-R.delta,!1):R.type===hn.pop&&Ye(h,20)&&r.go(-1,!1)),Q(j,u,h)}).catch(tn)}))}let ye=Ut(),re=Ut(),q;function X(v,M,R){it(v);const j=re.list();return j.length?j.forEach(oe=>oe(v,M,R)):console.error(v),Promise.reject(v)}function ze(){return q&&c.value!==ct?Promise.resolve():new Promise((v,M)=>{ye.add([v,M])})}function it(v){return q||(q=!v,ae(),ye.list().forEach(([M,R])=>v?R(v):M()),ye.reset()),v}function $e(v,M,R,j){const{scrollBehavior:oe}=e;if(!It||!oe)return Promise.resolve();const u=!R&&nu(zr(v.fullPath,0))||(j||!R)&&history.state&&history.state.scroll||null;return Gn().then(()=>oe(v,M,u)).then(h=>h&&eu(h)).catch(h=>X(h,v,M))}const Se=v=>r.go(v);let At;const Pt=new Set,vn={currentRoute:c,listening:!0,addRoute:m,removeRoute:x,clearRoutes:t.clearRoutes,hasRoute:k,getRoutes:A,resolve:N,options:e,push:L,replace:V,go:Se,back:()=>Se(-1),forward:()=>Se(1),beforeEach:o.add,beforeResolve:i.add,afterEach:l.add,onError:re.add,isReady:ze,install(v){const M=this;v.component("RouterLink",Cu),v.component("RouterView",Tu),v.config.globalProperties.$router=M,Object.defineProperty(v.config.globalProperties,"$route",{enumerable:!0,get:()=>Ft(c)}),It&&!At&&c.value===ct&&(At=!0,L(r.location).catch(oe=>{}));const R={};for(const oe in ct)Object.defineProperty(R,oe,{get:()=>c.value[oe],enumerable:!0});v.provide(ts,M),v.provide(tr,Fo(R)),v.provide(Is,c);const j=v.unmount;Pt.add(v),v.unmount=function(){Pt.delete(v),Pt.size<1&&(a=ct,z&&z(),z=null,c.value=ct,At=!1,q=!1),j()}}};function Te(v){return v.reduce((M,R)=>M.then(()=>T(R)),Promise.resolve())}return vn}function Ou(e,t){const n=[],s=[],r=[],o=Math.max(t.matched.length,e.matched.length);for(let i=0;i<o;i++){const l=t.matched[i];l&&(e.matched.find(a=>$t(a,l))?s.push(l):n.push(l));const c=e.matched[i];c&&(t.matched.find(a=>$t(a,c))||r.push(c))}return[n,s,r]}function Qu(){return Le(ts)}function Yu(e){return Le(tr)}export{Mu as A,$l as B,Mc as C,Nu as D,Gu as E,Ue as F,Yu as G,Qu as H,Ju as I,zu as J,Wu as K,qu as L,Hu as T,mn as a,ju as b,Me as c,wi as d,$u as e,Iu as f,Bu as g,Zs as h,Du as i,ti as j,$s as k,Nc as l,Fu as m,Ds as n,Tc as o,Gn as p,Xt as q,Wn as r,Zo as s,rl as t,we as u,ku as v,Ku as w,Lu as x,Vu as y,Uu as z};
-//# sourceMappingURL=vendor-Ctwcxhgt.js.map

frontend/dist/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="de">
-<head>
-  <meta charset="UTF-8" />
-  <link rel="icon" type="image/svg+xml" href="/vite.svg" />
-  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>SAAP - Multi-Agent Platform</title>
-  <meta name="description" content="satware AI Autonomous Agent Platform - Lokale Multi-Agent Verwaltung" />
-  <script type="module" crossorigin src="/assets/index-RrLk96-w.js"></script>
-  <link rel="modulepreload" crossorigin href="/assets/vendor-Ctwcxhgt.js">
-  <link rel="stylesheet" crossorigin href="/assets/index-C4sh0Su3.css">
-</head>
-<body>
-  <div id="app"></div>
-</body>
-</html>

frontend/nginx.conf

@@ -54,7 +54,7 @@ http {
 
         # API proxy to backend
         location /api/ {
-            proxy_pass http://backend:8000/api/;
+            proxy_pass http://backend:8000/;
             proxy_http_version 1.1;
             proxy_set_header Upgrade $http_upgrade;
             proxy_set_header Connection 'upgrade';

frontend/src/App.vue

@@ -4,59 +4,12 @@
     <header class="saap-header">
       <div class="header-content">
         <div class="logo-section">
-          <router-link to="/" class="logo-link">
-            <h1 class="saap-heading-2">
-              <span class="logo-text">SAAP</span>
-              <span class="logo-subtitle">Multi-Agent Platform</span>
-            </h1>
-          </router-link>
+          <h1 class="saap-heading-2">
+            <span class="logo-text">SAAP</span>
+            <span class="logo-subtitle">Multi-Agent Platform</span>
+          </h1>
         </div>
         
-        <!-- Navigation Icons -->
-        <nav class="nav-section">
-          <router-link to="/" class="nav-icon" :class="{ active: $route.path === '/' }" title="Dashboard">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <rect x="3" y="3" width="7" height="7"></rect>
-              <rect x="14" y="3" width="7" height="7"></rect>
-              <rect x="14" y="14" width="7" height="7"></rect>
-              <rect x="3" y="14" width="7" height="7"></rect>
-            </svg>
-            <span class="nav-label">Dashboard</span>
-          </router-link>
-          
-          <router-link to="/costs" class="nav-icon" :class="{ active: $route.path === '/costs' }" title="Cost Analytics">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <line x1="12" y1="1" x2="12" y2="23"></line>
-              <path d="M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6"></path>
-            </svg>
-            <span class="nav-label">Costs</span>
-          </router-link>
-          
-          <router-link to="/monitoring" class="nav-icon" :class="{ active: $route.path === '/monitoring' }" title="System Monitoring">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <path d="M22 12h-4l-3 9L9 3l-3 9H2"></path>
-            </svg>
-            <span class="nav-label">Monitoring</span>
-          </router-link>
-          
-          <router-link to="/settings" class="nav-icon" :class="{ active: $route.path === '/settings' }" title="Settings">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <circle cx="12" cy="12" r="3"></circle>
-              <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path>
-            </svg>
-            <span class="nav-label">Settings</span>
-          </router-link>
-          
-          <router-link to="/about" class="nav-icon" :class="{ active: $route.path === '/about' }" title="About SAAP">
-            <svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-              <circle cx="12" cy="12" r="10"></circle>
-              <line x1="12" y1="16" x2="12" y2="12"></line>
-              <line x1="12" y1="8" x2="12.01" y2="8"></line>
-            </svg>
-            <span class="nav-label">About</span>
-          </router-link>
-        </nav>
-        
         <div class="status-section">
           <div class="connection-status" :class="connectionStatusClass">
             <div class="status-dot"></div>
@@ -71,9 +24,9 @@
       </div>
     </header>
 
-    <!-- Main Content Area - Router View -->
+    <!-- Main Content Area - Direct Dashboard -->
     <main class="saap-main">
-      <router-view />
+      <SaapDashboard />
     </main>
 
     <!-- Footer -->
@@ -82,7 +35,7 @@
         <span class="footer-text">
           SAAP v1.0.0 • 
           Built with Vue.js • 
-          Powered by Hanan Wandji
+          Powered by colossus Server
         </span>
         <span class="footer-build">
           Build: {{ buildDate }}
@@ -215,50 +168,6 @@ export default {
   color: var(--saap-gray-600);
 }
 
-.logo-link {
-  text-decoration: none;
-  color: inherit;
-}
-
-/* Navigation Section */
-.nav-section {
-  display: flex;
-  align-items: center;
-  gap: var(--saap-space-2);
-}
-
-.nav-icon {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  gap: var(--saap-space-1);
-  padding: var(--saap-space-2) var(--saap-space-3);
-  border-radius: var(--saap-radius-lg);
-  color: var(--saap-gray-500);
-  text-decoration: none;
-  transition: all var(--saap-transition-base);
-}
-
-.nav-icon:hover {
-  background: var(--saap-gray-100);
-  color: var(--saap-primary-600);
-}
-
-.nav-icon.active {
-  background: linear-gradient(135deg, rgba(79, 70, 229, 0.1), rgba(34, 197, 94, 0.1));
-  color: var(--saap-primary-600);
-}
-
-.nav-icon svg {
-  width: 20px;
-  height: 20px;
-}
-
-.nav-label {
-  font-size: var(--saap-text-xs);
-  font-weight: var(--saap-font-medium);
-}
-
 /* Status Section */
 .status-section {
   display: flex;
@@ -351,30 +260,14 @@ export default {
 @media (max-width: 768px) {
   .header-content {
     flex-direction: column;
-    gap: var(--saap-space-3);
-    padding: var(--saap-space-3);
+    gap: var(--saap-space-4);
+    padding: var(--saap-space-4);
   }
   
   .logo-subtitle {
     display: none;
   }
   
-  .nav-section {
-    order: 3;
-    width: 100%;
-    justify-content: center;
-    border-top: 1px solid var(--saap-gray-200);
-    padding-top: var(--saap-space-3);
-  }
-  
-  .nav-label {
-    display: none;
-  }
-  
-  .nav-icon {
-    padding: var(--saap-space-2);
-  }
-  
   .status-section {
     gap: var(--saap-space-4);
   }

frontend/src/components/modals/MultiAgentChatModal.vue

@@ -123,38 +123,6 @@
 
       <!-- 🚀 INPUT BEREICH GARANTIERT SICHTBAR -->
       <div class="chat-input-section">
-        <!-- 📄 Document Upload Area -->
-        <div v-if="uploadedDocument" class="uploaded-document">
-          <div class="document-info">
-            <span class="document-icon">📄</span>
-            <div class="document-details">
-              <span class="document-name">{{ uploadedDocument.filename }}</span>
-              <span class="document-size">{{ formatFileSize(uploadedDocument.size) }}</span>
-            </div>
-            <div v-if="uploadedDocument.privacyInfo" class="document-privacy">
-              <span v-if="uploadedDocument.privacyInfo?.use_local" class="privacy-indicator sensitive">
-                🔒 Sensible Daten erkannt
-              </span>
-              <span v-else class="privacy-indicator safe">
-                ✅ Keine sensiblen Daten
-              </span>
-            </div>
-          </div>
-          <button @click="removeDocument" class="remove-document" title="Dokument entfernen">
-            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
-            </svg>
-          </button>
-        </div>
-
-        <!-- 📤 Upload Progress -->
-        <div v-if="isUploading" class="upload-progress">
-          <div class="progress-bar-container">
-            <div class="progress-bar-fill" :style="{ width: uploadProgress + '%' }"></div>
-          </div>
-          <span class="progress-text">{{ uploadProgress }}% - {{ uploadStatus }}</span>
-        </div>
-
         <div class="input-group">
           <textarea
             v-model="currentMessage"
@@ -165,33 +133,16 @@
             rows="3"
             :disabled="isProcessing"
           ></textarea>
-          <div class="input-buttons">
-            <!-- 📎 File Upload Button -->
-            <label for="file-upload" class="file-upload-button" :class="{ disabled: isProcessing || isUploading }">
-              <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15.172 7l-6.586 6.586a2 2 0 102.828 2.828l6.414-6.586a4 4 0 00-5.656-5.656l-6.415 6.585a6 6 0 108.486 8.486L20.5 13"></path>
-              </svg>
-              <input 
-                id="file-upload"
-                type="file"
-                accept=".pdf,.docx,.txt"
-                @change="handleFileUpload"
-                :disabled="isProcessing || isUploading"
-                style="display: none;"
-              />
-            </label>
-            
-            <button 
-              @click="sendMessage"
-              :disabled="!canSendMessage"
-              class="send-button"
-            >
-              <svg v-if="!isProcessing" class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 19l9 2-9-18-9 18 9-2zm0 0v-8"></path>
-              </svg>
-              <div v-else class="spinner"></div>
-            </button>
-          </div>
+          <button 
+            @click="sendMessage"
+            :disabled="!canSendMessage"
+            class="send-button"
+          >
+            <svg v-if="!isProcessing" class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 19l9 2-9-18-9 18 9-2zm0 0v-8"></path>
+            </svg>
+            <div v-else class="spinner"></div>
+          </button>
         </div>
         
         <div class="input-options">
@@ -289,7 +240,7 @@
 </template>
 
 <script>
-import { ref, computed, nextTick, onMounted, watch, toRef } from 'vue'
+import { ref, computed, nextTick, onMounted } from 'vue'
 import { saapApi } from '../../services/saapApi'
 
 export default {
@@ -316,12 +267,6 @@ export default {
     const selectedProvider = ref('auto')
     const showPrivacyInfo = ref(false)
     
-    // 📄 Document Upload State
-    const uploadedDocument = ref(null)
-    const isUploading = ref(false)
-    const uploadProgress = ref(0)
-    const uploadStatus = ref('')
-    
     // Available specialists data
     const availableSpecialists = ref([
       {
@@ -454,10 +399,6 @@ export default {
       
       chatMessages.value.push(message)
       scrollToBottom()
-      
-      // 💾 Auto-save to PostgreSQL (async, non-blocking)
-      saveMessageToDb(message)
-      
       return message
     }
 
@@ -504,34 +445,16 @@ export default {
           provider = null // Let backend decide
         }
 
-        // 📄 Build message with document context if available
-        let fullMessage = message
-        if (uploadedDocument.value && uploadedDocument.value.parsedText) {
-          const docContext = `\n\n📄 **Dokument-Kontext (${uploadedDocument.value.filename}):**\n${uploadedDocument.value.parsedText}`
-          fullMessage = message + docContext
-          
-          // Show info that document is included
-          processingStatus.value = 'Analysiert Dokument + Anfrage...'
-        }
-
         // Call multi-agent API with provider selection
-        const response = await saapApi.multiAgentChat(fullMessage, {
+        const response = await saapApi.multiAgentChat(message, {
           user_context: {
             timestamp: new Date().toISOString().split('.')[0] + 'Z',  // 🔧 FIX: Remove milliseconds for Python compatibility
-            priority: taskPriority.value,
-            has_document: !!uploadedDocument.value,
-            document_name: uploadedDocument.value?.filename || null
+            priority: taskPriority.value
           },
           preferred_agent: preferredAgent.value || null,
           task_priority: taskPriority.value,
           provider: provider,
-          privacy_mode: forceProvider || selectedProvider.value,
-          document_context: uploadedDocument.value ? {
-            filename: uploadedDocument.value.filename,
-            content: uploadedDocument.value.parsedText,
-            size: uploadedDocument.value.size,
-            is_sensitive: uploadedDocument.value.privacyInfo?.use_local || false
-          } : null
+          privacy_mode: forceProvider || selectedProvider.value
         })
 
         // Update coordination chain based on backend response
@@ -616,130 +539,6 @@ export default {
       }
     }
 
-    // 📄 Document Upload Functions
-    const handleFileUpload = async (event) => {
-      const file = event.target.files?.[0]
-      if (!file) return
-
-      // Validate file size (max 10MB)
-      const maxSize = 10 * 1024 * 1024 // 10MB
-      if (file.size > maxSize) {
-        addMessage(
-          `❌ Datei zu groß: ${formatFileSize(file.size)}. Maximum: 10MB`,
-          'system',
-          'System',
-          'error',
-          { role: 'Upload Error' }
-        )
-        event.target.value = '' // Reset input
-        return
-      }
-
-      // Validate file type
-      const allowedTypes = ['.pdf', '.docx', '.txt']
-      const fileExtension = '.' + file.name.split('.').pop().toLowerCase()
-      if (!allowedTypes.includes(fileExtension)) {
-        addMessage(
-          `❌ Ungültiger Dateityp: ${fileExtension}. Erlaubt: PDF, DOCX, TXT`,
-          'system',
-          'System',
-          'error',
-          { role: 'Upload Error' }
-        )
-        event.target.value = '' // Reset input
-        return
-      }
-
-      try {
-        isUploading.value = true
-        uploadProgress.value = 0
-        uploadStatus.value = 'Uploading document...'
-
-        // Upload to backend via saapApi (uses correct base URL for environment)
-        uploadProgress.value = 50 // Simulated progress
-        const data = await saapApi.uploadDocument(file)
-        
-        // 🔧 FIX: Defensive handling of backend response
-        const hasSensitiveData = data?.has_sensitive_data ?? data?.is_sensitive ?? false
-        const sensitiveDataTypes = data?.sensitive_data_types ?? data?.detected_types ?? []
-        
-        // Store uploaded document info with null-safe access
-        // 📄 Use full_content for complete document analysis, fallback to content_preview
-        uploadedDocument.value = {
-          filename: data?.filename ?? file.name,
-          size: data?.file_size ?? file.size,
-          documentId: data?.document_id ?? null,
-          charCount: data?.char_count ?? 0,
-          privacyInfo: {
-            use_local: hasSensitiveData,
-            sensitive_types: sensitiveDataTypes
-          },
-          parsedText: data?.full_content ?? data?.content_preview ?? ''
-        }
-
-        uploadProgress.value = 100
-        uploadStatus.value = 'Upload complete!'
-
-        // 🔧 FIX: Add success message to chat with null-safe access
-        const privacyStatus = hasSensitiveData 
-          ? '🔒 Sensible Daten erkannt - wird intern verarbeitet'
-          : '✅ Keine sensiblen Daten'
-        
-        addMessage(
-          `📄 Dokument hochgeladen: ${uploadedDocument.value.filename} (${formatFileSize(uploadedDocument.value.size)})\n${privacyStatus}`,
-          'system',
-          'System',
-          'coordinator',
-          { role: 'Upload Success' }
-        )
-
-        // Clear file input
-        event.target.value = ''
-
-        // Show privacy toast if sensitive data detected
-        if (hasSensitiveData) {
-          showPrivacyInfo.value = true
-          setTimeout(() => {
-            showPrivacyInfo.value = false
-          }, 3000)
-        }
-
-      } catch (error) {
-        console.error('Document Upload Error:', error)
-        addMessage(
-          `❌ Upload fehlgeschlagen: ${error.message}`,
-          'system',
-          'System',
-          'error',
-          { role: 'Upload Error' }
-        )
-        event.target.value = '' // Reset input
-      } finally {
-        isUploading.value = false
-        uploadProgress.value = 0
-        uploadStatus.value = ''
-      }
-    }
-
-    const removeDocument = () => {
-      uploadedDocument.value = null
-      addMessage(
-        '🗑️ Dokument entfernt',
-        'system',
-        'System',
-        'coordinator',
-        { role: 'Document Removed' }
-      )
-    }
-
-    const formatFileSize = (bytes) => {
-      if (bytes === 0) return '0 Bytes'
-      const k = 1024
-      const sizes = ['Bytes', 'KB', 'MB', 'GB']
-      const i = Math.floor(Math.log(bytes) / Math.log(k))
-      return Math.round(bytes / Math.pow(k, i) * 100) / 100 + ' ' + sizes[i]
-    }
-
     const checkPrivacy = async (message) => {
       // Simple client-side privacy detection
       const sensitiveKeywords = {
@@ -942,68 +741,10 @@ Jane Alesi ist deine Master Coordinatorin. Sie analysiert deine Anfragen und del
       addMessage(helpMessage, 'system', 'System', 'coordinator', { role: 'Help & Documentation' })
     }
 
-    // Load chat history from PostgreSQL
-    const loadChatHistory = async () => {
-      try {
-        const history = await saapApi.getMultiAgentHistory('default', 5)
-        if (history.messages && history.messages.length > 0) {
-          chatMessages.value = history.messages.map(msg => ({
-            id: msg.id || Date.now() + Math.random(),
-            content: msg.content,
-            agent: msg.agent,
-            agentName: msg.agentName,
-            type: msg.type,
-            timestamp: msg.timestamp ? new Date(msg.timestamp) : new Date(),
-            role: msg.role,
-            processingTime: msg.processingTime,
-            cost: msg.cost,
-            provider: msg.provider
-          }))
-          scrollToBottom()
-          console.log(`📜 Loaded ${history.messages.length} messages from history`)
-        } else {
-          // No history, show welcome message
-          clearChat()
-        }
-      } catch (error) {
-        console.error('Failed to load chat history:', error)
-        clearChat()
-      }
-    }
-
-    // Save message to PostgreSQL
-    const saveMessageToDb = async (message) => {
-      try {
-        await saapApi.saveMultiAgentMessage({
-          session_id: 'default',
-          content: message.content,
-          agent: message.agent,
-          agentName: message.agentName,
-          type: message.type,
-          role: message.role,
-          provider: message.provider,
-          processingTime: message.processingTime,
-          cost: message.cost
-        })
-      } catch (error) {
-        console.error('Failed to save message:', error)
-      }
-    }
-
-    // Watch for modal visibility changes - load history when modal opens
-    const isVisibleRef = toRef(props, 'isVisible')
-    watch(isVisibleRef, (newValue, oldValue) => {
-      if (newValue && !oldValue) {
-        // Modal just opened - load chat history
-        console.log('📂 Modal opened - loading chat history...')
-        loadChatHistory()
-      }
-    })
-
     // Lifecycle
     onMounted(() => {
-      if (props.isVisible) {
-        loadChatHistory()
+      if (chatMessages.value.length === 0) {
+        clearChat()
       }
     })
 
@@ -1022,10 +763,6 @@ Jane Alesi ist deine Master Coordinatorin. Sie analysiert deine Anfragen und del
       availableSpecialists,
       selectedProvider,
       showPrivacyInfo,
-      uploadedDocument,
-      isUploading,
-      uploadProgress,
-      uploadStatus,
       
       // Computed
       canSendMessage,
@@ -1043,10 +780,7 @@ Jane Alesi ist deine Master Coordinatorin. Sie analysiert deine Anfragen und del
       showSystemStatus,
       showPerformanceReport,
       showListAgents,
-      showHelp,
-      handleFileUpload,
-      removeDocument,
-      formatFileSize
+      showHelp
     }
   }
 }
@@ -1555,174 +1289,12 @@ Jane Alesi ist deine Master Coordinatorin. Sie analysiert deine Anfragen und del
   flex-shrink: 0;
 }
 
-/* 📄 Document Upload Styles */
-.uploaded-document {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  padding: 12px;
-  margin-bottom: 12px;
-  background: #f0f9ff;
-  border: 1px solid #38bdf8;
-  border-radius: 8px;
-}
-
-.document-info {
-  display: flex;
-  align-items: center;
-  gap: 12px;
-  flex: 1;
-}
-
-.document-icon {
-  font-size: 24px;
-}
-
-.document-details {
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-
-.document-name {
-  font-size: 14px;
-  font-weight: 600;
-  color: #0c4a6e;
-}
-
-.document-size {
-  font-size: 12px;
-  color: #6b7280;
-}
-
-.document-privacy {
-  display: flex;
-  align-items: center;
-}
-
-.privacy-indicator {
-  padding: 4px 10px;
-  border-radius: 6px;
-  font-size: 11px;
-  font-weight: 600;
-}
-
-.privacy-indicator.sensitive {
-  background: #dcfce7;
-  color: #16a34a;
-}
-
-.privacy-indicator.safe {
-  background: #dbeafe;
-  color: #2563eb;
-}
-
-.remove-document {
-  padding: 6px;
-  background: #fee2e2;
-  border: 1px solid #fca5a5;
-  border-radius: 6px;
-  color: #dc2626;
-  cursor: pointer;
-  transition: all 0.2s;
-}
-
-.remove-document:hover {
-  background: #fecaca;
-  transform: scale(1.05);
-}
-
-.remove-document svg {
-  width: 16px;
-  height: 16px;
-}
-
-/* 📤 Upload Progress Styles */
-.upload-progress {
-  margin-bottom: 12px;
-  padding: 12px;
-  background: #f0f9ff;
-  border: 1px solid #38bdf8;
-  border-radius: 8px;
-}
-
-.progress-bar-container {
-  width: 100%;
-  height: 8px;
-  background: #e0f2fe;
-  border-radius: 4px;
-  overflow: hidden;
-  margin-bottom: 8px;
-}
-
-.progress-bar-fill {
-  height: 100%;
-  background: linear-gradient(90deg, #3b82f6, #2563eb);
-  transition: width 0.3s ease;
-  border-radius: 4px;
-}
-
-.progress-text {
-  font-size: 12px;
-  color: #0c4a6e;
-  font-weight: 500;
-  text-align: center;
-  display: block;
-}
-
-/* Input Group with Buttons */
 .input-group {
   display: flex;
   gap: 12px;
   margin-bottom: 12px;
 }
 
-.input-buttons {
-  display: flex;
-  flex-direction: column;
-  gap: 8px;
-  align-self: flex-end;
-}
-
-/* 📎 File Upload Button */
-.file-upload-button {
-  background: linear-gradient(135deg, #10b981 0%, #059669 100%);
-  color: white;
-  border: none;
-  border-radius: 8px;
-  padding: 12px 16px;
-  cursor: pointer;
-  transition: all 0.2s;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-width: 48px;
-}
-
-.file-upload-button:hover:not(.disabled) {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
-}
-
-.file-upload-button.disabled {
-  background: #9ca3af;
-  cursor: not-allowed;
-  transform: none;
-}
-
-.file-upload-button svg {
-  width: 20px;
-  height: 20px;
-}
-
-.w-4 {
-  width: 1rem;
-}
-
-.h-4 {
-  height: 1rem;
-}
-
 .message-input {
   flex: 1;
   border: 2px solid #e5e7eb;

frontend/src/composables/useApi.ts

@@ -63,20 +63,8 @@ interface SystemStatus {
   timestamp: string
 }
 
-// 🌐 Environment-aware API Configuration (HuggingFace compatible)
-const getApiBaseUrl = () => {
-  if (typeof window !== 'undefined') {
-    if (window.location.hostname.includes('hf.space')) {
-      return '';  // Relative URLs for HuggingFace
-    }
-    if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
-      return 'http://localhost:8000';
-    }
-  }
-  return '';  // Fallback: relative URLs
-}
-
-const API_BASE_URL = getApiBaseUrl()
+// API Configuration
+const API_BASE_URL = 'http://localhost:8000'
 
 const api = axios.create({
   baseURL: API_BASE_URL,
@@ -86,8 +74,6 @@ const api = axios.create({
   },
 })
 
-console.log('🔧 useApi Configuration:', { API_BASE_URL, hostname: typeof window !== 'undefined' ? window.location.hostname : 'SSR' })
-
 // Request/Response interceptors
 api.interceptors.request.use(
   (config) => {
@@ -281,4 +267,4 @@ export const useApi = () => {
 }
 
 // Export types for use in components
-export type { SaapAgent, ChatMessage, SystemStatus }
+export type { SaapAgent, ChatMessage, SystemStatus }

frontend/src/composables/useWebSocket.ts

@@ -1,4 +1,4 @@
- /**
+/**
  * SAAP WebSocket Composable - Real-time Updates
  * WebSocket connection for live agent status and message updates
  */
@@ -38,28 +38,12 @@ export const useWebSocket = () => {
   const messages = ref<WebSocketMessage[]>([])
   const lastMessage = ref<WebSocketMessage | null>(null)
   
-  // 🌐 Environment-aware WebSocket URL (HuggingFace compatible)
-  const getWebSocketUrl = () => {
-    if (typeof window !== 'undefined') {
-      const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-      if (window.location.hostname.includes('hf.space')) {
-        return `${wsProtocol}//${window.location.host}/ws`;
-      }
-      if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
-        return 'ws://localhost:8000/ws';
-      }
-      return `${wsProtocol}//${window.location.host}/ws`;
-    }
-    return 'ws://localhost:8000/ws';  // Fallback for SSR
-  }
-  
-  const WS_URL = getWebSocketUrl()
+  // WebSocket URL (matching FastAPI WebSocket endpoint)
+  const WS_URL = 'ws://localhost:8000/ws'
   const RECONNECT_DELAY = 3000
   const MAX_RECONNECT_ATTEMPTS = 5
   let reconnectAttempts = 0
   
-  console.log('🔧 useWebSocket Configuration:', { WS_URL, hostname: typeof window !== 'undefined' ? window.location.hostname : 'SSR' })
-  
   // Event listeners
   const eventListeners = new Map<string, Set<Function>>()
   
@@ -350,4 +334,4 @@ export const useWebSocket = () => {
 }
 
 // Export types
-export type { WebSocketMessage, ConnectionStatus }
+export type { WebSocketMessage, ConnectionStatus }

frontend/src/main.js

@@ -11,33 +11,11 @@ import App from './App.vue'
 // Import global styles
 import './assets/css/main.css'
 
-// 🌐 Environment-aware Configuration (HuggingFace compatible)
-const getApiBaseUrl = () => {
-  if (window.location.hostname.includes('hf.space')) {
-    return '/api/v1';
-  }
-  if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
-    return 'http://localhost:8000';
-  }
-  return '';  // Relative for production
-}
-
-const getWebSocketUrl = () => {
-  const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-  if (window.location.hostname.includes('hf.space')) {
-    return `${wsProtocol}//${window.location.host}/ws`;
-  }
-  if (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1') {
-    return 'ws://localhost:8000/ws';
-  }
-  return `${wsProtocol}//${window.location.host}/ws`;
-}
-
 // SAAP Configuration
 const SAAP_CONFIG = {
   version: '1.0.0',
-  apiBaseUrl: getApiBaseUrl(),
-  websocketUrl: getWebSocketUrl(),
+  apiBaseUrl: 'http://localhost:8000',
+  websocketUrl: 'ws://localhost:8000/ws',
   debug: import.meta.env.DEV,
   buildDate: new Date().toLocaleDateString('de-DE')
 }
@@ -81,4 +59,4 @@ console.log('📊 Configuration:', SAAP_CONFIG)
 if (SAAP_CONFIG.debug) {
   window.__SAAP_APP__ = app
   window.__SAAP_CONFIG__ = SAAP_CONFIG
-}
+}

frontend/src/router/index.js

@@ -9,8 +9,6 @@ import DashboardSimple from '@/views/DashboardSimple.vue'
 import AgentDetails from '@/views/AgentDetails.vue'
 import Settings from '@/views/Settings.vue'
 import About from '@/views/About.vue'
-import Costs from '@/views/Costs.vue'
-import Monitoring from '@/views/Monitoring.vue'
 
 const router = createRouter({
   history: createWebHistory(import.meta.env.BASE_URL),
@@ -52,24 +50,6 @@ const router = createRouter({
         requiresAuth: false
       }
     },
-    {
-      path: '/costs',
-      name: 'Costs',
-      component: Costs,
-      meta: {
-        title: 'Cost Analytics',
-        requiresAuth: false
-      }
-    },
-    {
-      path: '/monitoring',
-      name: 'Monitoring',
-      component: Monitoring,
-      meta: {
-        title: 'System Monitoring',
-        requiresAuth: false
-      }
-    },
     {
       path: '/about',
       name: 'About',

frontend/src/services/saapApi.js

@@ -138,22 +138,6 @@ const saapApi = {
     return response.data;
   },
 
-  // Multi-Agent Chat History (PostgreSQL persistence)
-  async getMultiAgentHistory(sessionId = 'default', limit = 5) {
-    const response = await apiClient.get(`/multi-agent/history?session_id=${sessionId}&limit=${limit}`);
-    return response.data;
-  },
-
-  async saveMultiAgentMessage(message) {
-    const response = await apiClient.post('/multi-agent/history/message', message);
-    return response.data;
-  },
-
-  async clearMultiAgentHistory(sessionId = 'default') {
-    const response = await apiClient.delete(`/multi-agent/history?session_id=${sessionId}`);
-    return response.data;
-  },
-
   // Templates
   async getAgentTemplates() {
     const response = await apiClient.get('/templates/agents');
@@ -170,69 +154,6 @@ const saapApi = {
     const response = await apiClient.get('/health');
     return response.data;
   },
-
-  // Document Upload
-  async uploadDocument(file, userMessage = null) {
-    const formData = new FormData();
-    formData.append('file', file);
-    if (userMessage) {
-      formData.append('user_message', userMessage);
-    }
-    
-    const response = await apiClient.post('/documents/upload', formData, {
-      headers: {
-        'Content-Type': 'multipart/form-data',
-      },
-      timeout: 60000, // 60 seconds for file upload
-    });
-    return response.data;
-  },
-
-  // Document Analysis
-  async analyzeDocument(file) {
-    const formData = new FormData();
-    formData.append('file', file);
-    
-    const response = await apiClient.post('/documents/analyze', formData, {
-      headers: {
-        'Content-Type': 'multipart/form-data',
-      },
-      timeout: 60000,
-    });
-    return response.data;
-  },
-
-  // Supported Document Formats
-  async getSupportedFormats() {
-    const response = await apiClient.get('/documents/supported-formats');
-    return response.data;
-  },
-
-  // Cost Tracking & Analytics
-  async getCostSummary(hours = 24) {
-    const response = await apiClient.get(`/cost/summary?hours=${hours}`);
-    return response.data;
-  },
-
-  async getCostAnalytics(hours = 24) {
-    const response = await apiClient.get(`/cost/analytics?hours=${hours}`);
-    return response.data;
-  },
-
-  async getBudgetStatus() {
-    const response = await apiClient.get('/cost/budget');
-    return response.data;
-  },
-
-  async getPerformanceBenchmarks(hours = 24) {
-    const response = await apiClient.get(`/cost/benchmarks?hours=${hours}`);
-    return response.data;
-  },
-
-  async getCostReport(hours = 24) {
-    const response = await apiClient.get(`/cost/report?hours=${hours}`);
-    return response.data;
-  },
 };
 
 // WebSocket connection for real-time updates

frontend/vite.config.js

@@ -19,21 +19,7 @@ export default defineConfig({
       '/api': {
         target: 'http://localhost:8000',
         changeOrigin: true,
-        secure: false,
-        configure: (proxy) => {
-          proxy.on('error', (err) => {
-            console.log('Proxy error:', err);
-          });
-          proxy.on('proxyReq', (proxyReq, req) => {
-            console.log('Proxying:', req.method, req.url, '→', 'http://localhost:8000' + req.url);
-          });
-        }
-      },
-      // WebSocket proxy
-      '/ws': {
-        target: 'ws://localhost:8000',
-        ws: true,
-        changeOrigin: true
+        rewrite: (path) => path.replace(/^\/api/, '')
       }
     }
   },
@@ -49,4 +35,4 @@ export default defineConfig({
       }
     }
   }
-})
+})