Update admin_routes.py

admin_routes.py

@@ -1,6 +1,6 @@
-"""Admin API endpoints for Flare
+"""Admin API endpoints for Flare (Refactored)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Provides authentication, project, version, and API management endpoints.
+Provides authentication, project, version, and API management endpoints with provider support.
 """
 
 import os
@@ -27,8 +27,8 @@ from encryption_utils import encrypt, decrypt
 # ===================== JWT Config =====================
 def get_jwt_config():
     """Get JWT configuration based on environment"""
-    # Check if running in HuggingFace Space
-    if os.environ.get("SPACE_ID"):
+    # Check if we're in HuggingFace Space
+    if os.getenv("SPACE_ID"):
         # Cloud mode - use secrets from environment
         jwt_secret = os.getenv("JWT_SECRET")
         if not jwt_secret:
@@ -73,6 +73,7 @@ class EnvironmentUpdate(BaseModel):
     llm_provider: ProviderSettingsUpdate
     tts_provider: ProviderSettingsUpdate
     stt_provider: ProviderSettingsUpdate
+    parameter_collection_config: Optional[Dict[str, Any]] = None
 
 class ProjectCreate(BaseModel):
     name: str
@@ -80,100 +81,101 @@ class ProjectCreate(BaseModel):
     icon: Optional[str] = "folder"  
     description: Optional[str] = ""  
     default_locale: str = "tr"
-    supported_locales: List[str] = ["tr"]
-
+    supported_locales: List[str] = Field(default_factory=lambda: ["tr"])
+    timezone: str = "Europe/Istanbul"  
+    region: str = "tr-TR"
+    
 class ProjectUpdate(BaseModel):
-    caption: Optional[str] = None
-    icon: Optional[str] = None
-    description: Optional[str] = None
-    default_locale: Optional[str] = None
-    supported_locales: Optional[List[str]] = None
-
+    caption: str
+    icon: Optional[str] = "folder"  
+    description: Optional[str] = ""  
+    default_locale: str = "tr"
+    supported_locales: List[str] = Field(default_factory=lambda: ["tr"])
+    timezone: str = "Europe/Istanbul"
+    region: str = "tr-TR"
+    last_update_date: str
+    
 class VersionCreate(BaseModel):
+    caption: str
+    source_version_id: int | None = None
+
+class IntentModel(BaseModel):
+    name: str
     caption: Optional[str] = ""
-    general_prompt: str
-    llm: Optional[Dict[str, Any]] = None
-    intents: List[Dict[str, Any]] = []
+    detection_prompt: str
+    examples: List[Dict[str, str]] = []  # LocalizedExample format
+    parameters: List[Dict[str, Any]] = []
+    action: str
+    fallback_timeout_prompt: Optional[str] = None
+    fallback_error_prompt: Optional[str] = None
 
 class VersionUpdate(BaseModel):
-    caption: Optional[str] = None
-    general_prompt: Optional[str] = None
-    llm: Optional[Dict[str, Any]] = None
-    intents: Optional[List[Dict[str, Any]]] = None
+    caption: str
+    general_prompt: str
+    llm: Dict[str, Any]
+    intents: List[IntentModel]
+    last_update_date: str
 
 class APICreate(BaseModel):
     name: str
     url: str
-    method: str = "GET"
-    headers: Dict[str, Any] = {}
+    method: str = "POST"
+    headers: Dict[str, str] = {}
     body_template: Dict[str, Any] = {}
     timeout_seconds: int = 10
+    retry: Dict[str, Any] = Field(default_factory=lambda: {"retry_count": 3, "backoff_seconds": 2, "strategy": "static"})
+    proxy: Optional[str] = None
     auth: Optional[Dict[str, Any]] = None
     response_prompt: Optional[str] = None
+    response_mappings: List[Dict[str, Any]] = []
 
 class APIUpdate(BaseModel):
-    url: Optional[str] = None
-    method: Optional[str] = None
-    headers: Optional[Dict[str, Any]] = None
-    body_template: Optional[Dict[str, Any]] = None
-    timeout_seconds: Optional[int] = None
-    auth: Optional[Dict[str, Any]] = None
-    response_prompt: Optional[str] = None
+    url: str
+    method: str
+    headers: Dict[str, str]
+    body_template: Dict[str, Any]
+    timeout_seconds: int
+    retry: Dict[str, Any]
+    proxy: Optional[str]
+    auth: Optional[Dict[str, Any]]
+    response_prompt: Optional[str]
+    response_mappings: List[Dict[str, Any]] = []
+    last_update_date: str
+    
+class TestRequest(BaseModel):
+    test_type: str  # "all", "ui", "backend", "integration", "spark"
 
 # ===================== Auth Helpers =====================
 def create_token(username: str) -> str:
-    """Create JWT token"""
-    jwt_config = get_jwt_config()
+    """Create JWT token for user"""
+    config = get_jwt_config()
+    expiry = datetime.now(timezone.utc) + timedelta(hours=config["expiration_hours"])
     
     payload = {
         "sub": username,
-        "exp": datetime.now(timezone.utc) + timedelta(hours=jwt_config["expiration_hours"]),
+        "exp": expiry,
         "iat": datetime.now(timezone.utc)
     }
     
-    return jwt.encode(payload, jwt_config["secret"], algorithm=jwt_config["algorithm"])
+    return jwt.encode(payload, config["secret"], algorithm=config["algorithm"])
 
 def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
     """Verify JWT token and return username"""
-    jwt_config = get_jwt_config()
+    token = credentials.credentials
+    config = get_jwt_config()
     
     try:
-        payload = jwt.decode(
-            credentials.credentials,
-            jwt_config["secret"],
-            algorithms=[jwt_config["algorithm"]]
-        )
-        username = payload.get("sub")
-        if not username:
-            raise HTTPException(status_code=401, detail="Invalid token")
-        return username
+        payload = jwt.decode(token, config["secret"], algorithms=[config["algorithm"]])
+        return payload["sub"]
     except jwt.ExpiredSignatureError:
         raise HTTPException(status_code=401, detail="Token expired")
     except jwt.InvalidTokenError:
         raise HTTPException(status_code=401, detail="Invalid token")
 
-def verify_password(plain_password: str, hashed_password: str, salt: str) -> bool:
-    """Verify password against hash"""
-    # For bcrypt hashes
-    if hashed_password.startswith("$2b$"):
-        return bcrypt.checkpw(plain_password.encode('utf-8'), hashed_password.encode('utf-8'))
-    
-    # For SHA256 hashes (legacy)
-    password_with_salt = plain_password + salt
-    password_hash = hashlib.sha256(password_with_salt.encode()).hexdigest()
-    return password_hash == hashed_password
-
-def hash_password(password: str) -> tuple[str, str]:
-    """Hash password and return (hash, salt)"""
-    # Use bcrypt for new passwords
-    salt = bcrypt.gensalt()
-    hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
-    return hashed.decode('utf-8'), ""  # bcrypt includes salt in hash
-
-# ===================== Login Endpoints =====================
+# ===================== Auth Endpoints =====================
 @router.post("/login", response_model=LoginResponse)
 async def login(request: LoginRequest):
-    """User login"""
+    """User login endpoint"""
     cfg = ConfigProvider.get()
     
     # Find user
@@ -182,13 +184,13 @@ async def login(request: LoginRequest):
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
     # Verify password
-    if not verify_password(request.password, user.password_hash, user.salt):
+    if not bcrypt.checkpw(request.password.encode('utf-8'), user.password_hash.encode('utf-8')):
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
     # Create token
     token = create_token(request.username)
     
-    log(f"✅ User '{request.username}' logged in")
+    log(f"✅ User '{request.username}' logged in successfully")
     return LoginResponse(token=token, username=request.username)
 
 @router.post("/change-password")
@@ -205,18 +207,19 @@ async def change_password(
         raise HTTPException(status_code=404, detail="User not found")
     
     # Verify current password
-    if not verify_password(request.current_password, user.password_hash, user.salt):
+    if not bcrypt.checkpw(request.current_password.encode('utf-8'), user.password_hash.encode('utf-8')):
         raise HTTPException(status_code=401, detail="Current password is incorrect")
     
-    # Hash new password
-    new_hash, new_salt = hash_password(request.new_password)
+    # Generate new password hash
+    salt = bcrypt.gensalt()
+    new_hash = bcrypt.hashpw(request.new_password.encode('utf-8'), salt)
     
     # Update user
-    user.password_hash = new_hash
-    user.salt = new_salt
+    user.password_hash = new_hash.decode('utf-8')
+    user.salt = salt.decode('utf-8')
     
-    # Save config
-    ConfigProvider._save()
+    # Save configuration
+    cfg.save()
     
     log(f"✅ Password changed for user '{username}'")
     return {"success": True}
@@ -252,15 +255,16 @@ async def get_locale_details(
 # ===================== Environment Endpoints =====================
 @router.get("/environment")
 async def get_environment(username: str = Depends(verify_token)):
-    """Get environment configuration"""
+    """Get environment configuration with provider info"""
     cfg = ConfigProvider.get()
     env_config = cfg.global_config
     
     return {
-        "llm_provider": env_config.llm_provider.model_dump(),
-        "tts_provider": env_config.tts_provider.model_dump(),
-        "stt_provider": env_config.stt_provider.model_dump(),
-        "providers": [p.model_dump() for p in env_config.providers]
+        "llm_provider": env_config.llm_provider.model_dump() if env_config.llm_provider else None,
+        "tts_provider": env_config.tts_provider.model_dump() if env_config.tts_provider else None,
+        "stt_provider": env_config.stt_provider.model_dump() if env_config.stt_provider else None,
+        "providers": [p.model_dump() for p in env_config.providers],
+        "parameter_collection_config": env_config.parameter_collection_config.model_dump()
     }
 
 @router.put("/environment")
@@ -268,7 +272,7 @@ async def update_environment(
     update: EnvironmentUpdate,
     username: str = Depends(verify_token)
 ):
-    """Update environment configuration"""
+    """Update environment configuration with provider validation"""
     log(f"📝 Updating environment config by {username}")
     
     cfg = ConfigProvider.get()
@@ -278,36 +282,41 @@ async def update_environment(
     if not llm_provider_def:
         raise HTTPException(status_code=400, detail=f"Unknown LLM provider: {update.llm_provider.name}")
     
-    # Validate requirements
     if llm_provider_def.requires_api_key and not update.llm_provider.api_key:
-        raise HTTPException(status_code=400, detail=f"API key is required for {update.llm_provider.name}")
+        raise HTTPException(status_code=400, detail=f"{llm_provider_def.display_name} requires API key")
     
     if llm_provider_def.requires_endpoint and not update.llm_provider.endpoint:
-        raise HTTPException(status_code=400, detail=f"Endpoint is required for {update.llm_provider.name}")
-
+        raise HTTPException(status_code=400, detail=f"{llm_provider_def.display_name} requires endpoint")
+    
     # Validate TTS provider
     tts_provider_def = cfg.global_config.get_provider_config("tts", update.tts_provider.name)
-    if not tts_provider_def and update.tts_provider.name != "no_tts":
+    if not tts_provider_def:
         raise HTTPException(status_code=400, detail=f"Unknown TTS provider: {update.tts_provider.name}")
     
-    if tts_provider_def and tts_provider_def.requires_api_key and not update.tts_provider.api_key:
-        raise HTTPException(status_code=400, detail=f"API key is required for {update.tts_provider.name}")
+    if tts_provider_def.requires_api_key and not update.tts_provider.api_key:
+        raise HTTPException(status_code=400, detail=f"{tts_provider_def.display_name} requires API key")
     
     # Validate STT provider
     stt_provider_def = cfg.global_config.get_provider_config("stt", update.stt_provider.name)
-    if not stt_provider_def and update.stt_provider.name != "no_stt":
+    if not stt_provider_def:
         raise HTTPException(status_code=400, detail=f"Unknown STT provider: {update.stt_provider.name}")
     
-    if stt_provider_def and stt_provider_def.requires_api_key and not update.stt_provider.api_key:
-        raise HTTPException(status_code=400, detail=f"API key is required for {update.stt_provider.name}")
+    if stt_provider_def.requires_api_key and not update.stt_provider.api_key:
+        raise HTTPException(status_code=400, detail=f"{stt_provider_def.display_name} requires API key")
     
     # Update via ConfigProvider
     ConfigProvider.update_environment(update.model_dump(), username)
     
-    log(f"✅ Environment updated by {username}")
+    log(f"✅ Environment updated to LLM: {update.llm_provider.name}, TTS: {update.tts_provider.name}, STT: {update.stt_provider.name} by {username}")
     return {"success": True}
 
 # ===================== Project Endpoints =====================
+@router.get("/projects/names")
+def list_enabled_projects():
+    """Get list of enabled project names for chat"""
+    cfg = ConfigProvider.get()
+    return [p.name for p in cfg.projects if p.enabled and not getattr(p, 'deleted', False)]
+
 @router.get("/projects")
 async def list_projects(
     include_deleted: bool = False,
@@ -323,31 +332,49 @@ async def list_projects(
     
     return [p.model_dump() for p in projects]
 
+@router.get("/projects/{project_id}")
+async def get_project(
+    project_id: int,
+    username: str = Depends(verify_token)
+):
+    """Get single project by ID"""
+    project = ConfigProvider.get_project(project_id)
+    if not project or getattr(project, 'deleted', False):
+        raise HTTPException(status_code=404, detail="Project not found")
+    
+    return project.model_dump()
+
 @router.post("/projects")
 async def create_project(
     project: ProjectCreate,
     username: str = Depends(verify_token)
 ):
-    """Create new project"""
+    """Create new project with initial version"""
+    # Validate supported locales
+    from locale_manager import LocaleManager
+    
+    invalid_locales = LocaleManager.validate_project_languages(project.supported_locales)
+    if invalid_locales:
+        available_locales = LocaleManager.get_available_locales_with_names()
+        available_codes = [locale['code'] for locale in available_locales]
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Unsupported locales: {', '.join(invalid_locales)}. Available locales: {', '.join(available_codes)}"
+        )
+    
+    # Check if default locale is in supported locales
+    if project.default_locale not in project.supported_locales:
+        raise HTTPException(
+            status_code=400,
+            detail="Default locale must be one of the supported locales"
+        )
+    
+    # Create project via ConfigProvider
     new_project = ConfigProvider.create_project(project.model_dump(), username)
     
     log(f"✅ Project '{project.name}' created by {username}")
     return new_project.model_dump()
 
-@router.get("/projects/{project_id}")
-async def get_project(
-    project_id: int,
-    username: str = Depends(verify_token)
-):
-    """Get project details"""
-    cfg = ConfigProvider.get()
-    project = next((p for p in cfg.projects if p.id == project_id), None)
-    
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    return project.model_dump()
-
 @router.put("/projects/{project_id}")
 async def update_project(
     project_id: int,
@@ -355,9 +382,22 @@ async def update_project(
     username: str = Depends(verify_token)
 ):
     """Update project"""
-    updated_project = ConfigProvider.update_project(project_id, update.model_dump(exclude_unset=True), username)
+    # Validate supported locales
+    from locale_manager import LocaleManager
+    
+    invalid_locales = LocaleManager.validate_project_languages(update.supported_locales)
+    if invalid_locales:
+        available_locales = LocaleManager.get_available_locales_with_names()
+        available_codes = [locale['code'] for locale in available_locales]
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unsupported locales: {', '.join(invalid_locales)}. Available locales: {', '.join(available_codes)}"
+        )
     
-    log(f"✅ Project {project_id} updated by {username}")
+    # Update via ConfigProvider
+    updated_project = ConfigProvider.update_project(project_id, update.model_dump(), username)
+    
+    log(f"✅ Project '{updated_project.name}' updated by {username}")
     return updated_project.model_dump()
 
 @router.delete("/projects/{project_id}")
@@ -365,16 +405,16 @@ async def delete_project(project_id: int, username: str = Depends(verify_token))
     """Delete project (soft delete)"""
     ConfigProvider.delete_project(project_id, username)
     
-    log(f"✅ Project {project_id} deleted by {username}")
+    log(f"✅ Project deleted by {username}")
     return {"success": True}
 
 @router.patch("/projects/{project_id}/toggle")
 async def toggle_project(project_id: int, username: str = Depends(verify_token)):
     """Toggle project enabled status"""
-    project = ConfigProvider.toggle_project(project_id, username)
+    enabled = ConfigProvider.toggle_project(project_id, username)
     
-    log(f"✅ Project {project_id} {'enabled' if project.enabled else 'disabled'} by {username}")
-    return {"success": True, "enabled": project.enabled}
+    log(f"✅ Project {'enabled' if enabled else 'disabled'} by {username}")
+    return {"enabled": enabled}
 
 # ===================== Version Endpoints =====================
 @router.get("/projects/{project_id}/versions")
@@ -384,9 +424,7 @@ async def list_versions(
     username: str = Depends(verify_token)
 ):
     """List project versions"""
-    cfg = ConfigProvider.get()
-    project = next((p for p in cfg.projects if p.id == project_id), None)
-    
+    project = ConfigProvider.get_project(project_id)
     if not project:
         raise HTTPException(status_code=404, detail="Project not found")
     
@@ -418,7 +456,7 @@ async def update_version(
     username: str = Depends(verify_token)
 ):
     """Update version"""
-    updated_version = ConfigProvider.update_version(project_id, version_id, update.model_dump(exclude_unset=True), username)
+    updated_version = ConfigProvider.update_version(project_id, version_id, update.model_dump(), username)
     
     log(f"✅ Version {version_id} updated for project {project_id} by {username}")
     return updated_version.model_dump()
@@ -434,7 +472,16 @@ async def publish_version(
     
     log(f"✅ Version {version_id} published for project '{project.name}' by {username}")
 
-    # TODO: Notify LLM provider if needed (only for Spark variants)
+    # Notify LLM provider if project is enabled and provider requires repo info
+    cfg = ConfigProvider.get()
+    llm_provider_def = cfg.global_config.get_provider_config("llm", cfg.global_config.llm_provider.name)
+    
+    if project.enabled and llm_provider_def and llm_provider_def.requires_repo_info:
+        try:
+            await notify_llm_startup(project, version)
+        except Exception as e:
+            log(f"⚠️ Failed to notify LLM provider: {e}")
+            # Don't fail the publish 
 
     return {"success": True}
 
@@ -450,72 +497,6 @@ async def delete_version(
     log(f"✅ Version {version_id} deleted for project {project_id} by {username}")
     return {"success": True}
 
-# ===================== Test Endpoints =====================
-@router.post("/test-connection")
-async def test_connection(
-    request: dict = Body(...),
-    username: str = Depends(verify_token)
-):
-    """Test connection to LLM endpoint"""
-    endpoint = request.get("endpoint", "").rstrip("/")
-    api_key = request.get("api_key", "")
-    provider_name = request.get("provider", "spark")
-    
-    if not endpoint:
-        raise HTTPException(status_code=400, detail="Endpoint is required")
-    
-    # For Spark variants
-    if provider_name in ("spark", "spark_cloud", "spark_onpremise"):
-        try:
-            headers = {
-                "Authorization": f"Bearer {api_key}",
-                "Content-Type": "application/json"
-            }
-            
-            async with httpx.AsyncClient(timeout=10) as client:
-                response = await client.get(f"{endpoint}/health", headers=headers)
-                
-                if response.status_code == 200:
-                    return {"success": True, "message": "Connection successful"}
-                else:
-                    return {"success": False, "message": f"Health check failed: {response.status_code}"}
-                    
-        except Exception as e:
-            log(f"❌ Connection test failed: {e}")
-            return {"success": False, "message": str(e)}
-    
-    # For other providers
-    return {"success": True, "message": "Provider doesn't require connection test"}
-
-@router.post("/validate/regex")
-async def validate_regex(
-    request: dict = Body(...),
-    username: str = Depends(verify_token)
-):
-    """Validate regex pattern"""
-    pattern = request.get("pattern", "")
-    test_value = request.get("test_value", "")
-    
-    try:
-        import re
-        compiled_regex = re.compile(pattern)
-        matches = bool(compiled_regex.match(test_value))
-        
-        return {
-            "valid": True,
-            "matches": matches,
-            "pattern": pattern,
-            "test_value": test_value
-        }
-    except Exception as e:
-        return {
-            "valid": False,
-            "matches": False,
-            "error": str(e),
-            "pattern": pattern,
-            "test_value": test_value
-        }
-        
 # ===================== API Endpoints =====================
 @router.get("/apis")
 async def list_apis(
@@ -547,7 +528,7 @@ async def update_api(
     username: str = Depends(verify_token)
 ):
     """Update API"""
-    updated_api = ConfigProvider.update_api(api_name, update.model_dump(exclude_unset=True), username)
+    updated_api = ConfigProvider.update_api(api_name, update.model_dump(), username)
     
     log(f"✅ API '{api_name}' updated by {username}")
     return updated_api.model_dump()
@@ -560,87 +541,150 @@ async def delete_api(api_name: str, username: str = Depends(verify_token)):
     log(f"✅ API '{api_name}' deleted by {username}")
     return {"success": True}
 
-@router.post("/apis/test")
-async def test_api(
+@router.post("/validate/regex")
+async def validate_regex(
     request: dict = Body(...),
     username: str = Depends(verify_token)
 ):
-    """Test API endpoint"""
-    from api_executor import test_api_call
-    
-    api_config = request.get("api_config")
-    test_params = request.get("test_params", {})
-    
-    if not api_config:
-        raise HTTPException(status_code=400, detail="API config is required")
+    """Validate regex pattern"""
+    pattern = request.get("pattern", "")
+    test_value = request.get("test_value", "")
     
     try:
-        result = await test_api_call(api_config, test_params)
+        import re
+        compiled_regex = re.compile(pattern)
+        matches = bool(compiled_regex.match(test_value))
+        
         return {
-            "success": True,
-            "status_code": result.get("status_code"),
-            "response": result.get("response"),
-            "headers": result.get("headers"),
-            "duration_ms": result.get("duration_ms")
+            "valid": True,
+            "matches": matches,
+            "pattern": pattern,
+            "test_value": test_value
         }
     except Exception as e:
-        log(f"❌ API test failed: {e}")
         return {
-            "success": False,
-            "error": str(e)
+            "valid": False,
+            "matches": False,
+            "error": str(e),
+            "pattern": pattern,
+            "test_value": test_value
         }
 
-# ===================== Activity Log =====================
-@router.get("/activity-log")
-async def get_activity_log(
-    limit: int = Query(50, ge=1, le=500),
-    offset: int = Query(0, ge=0),
+# ===================== Test Endpoints =====================
+@router.post("/test/run-all")
+async def run_all_tests(
+    request: TestRequest,
     username: str = Depends(verify_token)
 ):
-    """Get activity log entries"""
-    # TODO: Implement when activity logging is added
+    """Run all tests"""
+    log(f"🧪 Running {request.test_type} tests requested by {username}")
+    
+    # TODO: Implement test runner
+    # For now, return mock results
     return {
-        "entries": [],
-        "total": 0,
-        "limit": limit,
-        "offset": offset
+        "test_run_id": "test_" + datetime.now().isoformat(),
+        "status": "running",
+        "total_tests": 60,
+        "completed": 0,
+        "passed": 0,
+        "failed": 0,
+        "message": "Test run started"
     }
 
-# ===================== Health Check =====================
-@router.get("/health")
-async def health_check():
-    """Health check endpoint"""
+@router.get("/test/status/{test_run_id}")
+async def get_test_status(
+    test_run_id: str,
+    username: str = Depends(verify_token)
+):
+    """Get test run status"""
+    # TODO: Implement test status tracking
     return {
-        "status": "ok",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "version": "1.0.0"
+        "test_run_id": test_run_id,
+        "status": "completed",
+        "total_tests": 60,
+        "completed": 60,
+        "passed": 57,
+        "failed": 3,
+        "duration": 340.5,
+        "details": []
     }
 
-# ===================== Cleanup Task =====================
-_cleanup_thread = None
+# ===================== Activity Log =====================
+@router.get("/activity-log")
+async def get_activity_log(
+    limit: int = Query(100, ge=1, le=1000),
+    entity_type: Optional[str] = None,
+    username: str = Depends(verify_token)
+):
+    """Get activity log"""
+    cfg = ConfigProvider.get()
+    logs = cfg.activity_log
+    
+    # Filter by entity type if specified
+    if entity_type:
+        logs = [l for l in logs if l.entity_type == entity_type]
+    
+    # Return most recent entries
+    return logs[-limit:]
 
-def cleanup_activity_logs():
-    """Cleanup old activity logs periodically"""
+# ===================== Helper Functions =====================
+async def notify_llm_startup(project, version):
+    """Notify LLM provider about project startup"""
+    from llm_factory import LLMFactory
+    
+    try:
+        llm_provider = LLMFactory.create_provider()
+        
+        # Build project config for startup
+        project_config = {
+            "name": project.name,
+            "version_id": version.id,
+            "repo_id": version.llm.repo_id,
+            "generation_config": version.llm.generation_config,
+            "use_fine_tune": version.llm.use_fine_tune,
+            "fine_tune_zip": version.llm.fine_tune_zip
+        }
+        
+        success = await llm_provider.startup(project_config)
+        if success:
+            log(f"✅ LLM provider notified for project '{project.name}'")
+        else:
+            log(f"⚠️ LLM provider notification failed for project '{project.name}'")
+            
+    except Exception as e:
+        log(f"❌ Error notifying LLM provider: {e}")
+        raise
+
+# ===================== Cleanup Task =====================
+def cleanup_activity_log():
+    """Cleanup old activity log entries"""
     while True:
         try:
-            # Sleep for 24 hours
-            time.sleep(86400)
+            cfg = ConfigProvider.get()
+            
+            # Keep only last 30 days
+            cutoff = datetime.now() - timedelta(days=30)
+            cutoff_str = cutoff.isoformat() + "Z"
             
-            # TODO: Implement cleanup logic when activity logging is added
-            log("🧹 Running activity log cleanup...")
+            original_count = len(cfg.activity_log)
+            cfg.activity_log = [
+                log for log in cfg.activity_log 
+                if log.timestamp >= cutoff_str
+            ]
             
+            if len(cfg.activity_log) < original_count:
+                removed = original_count - len(cfg.activity_log)
+                log(f"🧹 Cleaned up {removed} old activity log entries")
+                cfg.save()
+                
         except Exception as e:
-            log(f"❌ Cleanup error: {e}")
+            log(f"❌ Activity log cleanup error: {e}")
+        
+        # Run every hour
+        time.sleep(3600)
 
 def start_cleanup_task():
-    """Start background cleanup task"""
-    global _cleanup_thread
-    if _cleanup_thread is None:
-        _cleanup_thread = threading.Thread(target=cleanup_activity_logs, daemon=True)
-        _cleanup_thread.start()
-        log("🧹 Started cleanup task")
-
-# ===================== Helper Functions =====================
-def _get_iso_timestamp() -> str:
-    """Get current timestamp in ISO format"""
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+    """Start the cleanup task in background"""
+    thread = threading.Thread(target=cleanup_activity_log, daemon=True)
+    thread.start()
+    log("🧹 Activity log cleanup task started")