Update admin_routes.py

admin_routes.py

@@ -21,15 +21,14 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from pydantic import BaseModel, Field
 
 from utils import log
-from config_provider import ConfigProvider
+from config_provider import ConfigProvider, ProviderSettings
 from encryption_utils import encrypt, decrypt
 
 # ===================== JWT Config =====================
 def get_jwt_config():
     """Get JWT configuration based on environment"""
-    work_mode = os.getenv("WORK_MODE", "on-premise")
-    
-    if work_mode == "hfcloud":
+    # Check if running in HuggingFace Space
+    if os.environ.get("SPACE_ID"):
         # Cloud mode - use secrets from environment
         jwt_secret = os.getenv("JWT_SECRET")
         if not jwt_secret:
@@ -63,264 +62,122 @@ class LoginResponse(BaseModel):
 class ChangePasswordRequest(BaseModel):
     current_password: str
     new_password: str
+
+class ProviderSettingsUpdate(BaseModel):
+    name: str
+    api_key: Optional[str] = None
+    endpoint: Optional[str] = None
+    settings: Dict[str, Any] = Field(default_factory=dict)
     
 class EnvironmentUpdate(BaseModel):
-    work_mode: str
-    cloud_token: Optional[str] = None
-    spark_endpoint: str
-    internal_prompt: Optional[str] = None
-    tts_engine: str = "no_tts"
-    tts_engine_api_key: Optional[str] = None
-    tts_settings: Optional[Dict[str, Any]] = None
-    stt_engine: str = "no_stt"
-    stt_engine_api_key: Optional[str] = None
-    stt_settings: Optional[Dict[str, Any]] = None
-    parameter_collection_config: Optional[Dict[str, Any]] = None
+    llm_provider: ProviderSettingsUpdate
+    tts_provider: ProviderSettingsUpdate
+    stt_provider: ProviderSettingsUpdate
 
 class ProjectCreate(BaseModel):
     name: str
     caption: Optional[str] = ""
     icon: Optional[str] = "folder"  
     description: Optional[str] = ""  
-    default_language: str = "Türkçe"  # Locale'in name alanı (Türkçe, English vb.)
-    supported_languages: List[str] = Field(default_factory=lambda: ["tr-TR"])  # Locale kodları
-    timezone: str = "Europe/Istanbul"  
-    region: str = "tr-TR"  
-    
+    default_locale: str = "tr"
+    supported_locales: List[str] = ["tr"]
+
 class ProjectUpdate(BaseModel):
-    caption: str
-    icon: Optional[str] = "folder"  
-    description: Optional[str] = ""  
-    default_language: str = "Türkçe"  # Locale'in name alanı
-    supported_languages: List[str] = Field(default_factory=lambda: ["tr-TR"])  # Locale kodları
-    timezone: str = "Europe/Istanbul"
-    region: str = "tr-TR"
-    last_update_date: str
-    
-class VersionCreate(BaseModel):
-    caption: str
-    source_version_id: int | None = None    # None → boş template
+    caption: Optional[str] = None
+    icon: Optional[str] = None
+    description: Optional[str] = None
+    default_locale: Optional[str] = None
+    supported_locales: Optional[List[str]] = None
 
-class IntentModel(BaseModel):
-    name: str
+class VersionCreate(BaseModel):
     caption: Optional[str] = ""
-    locale: str = "tr-TR"
-    detection_prompt: str
-    examples: List[str] = []
-    parameters: List[Dict[str, Any]] = []
-    action: str
-    fallback_timeout_prompt: Optional[str] = None
-    fallback_error_prompt: Optional[str] = None
+    general_prompt: str
+    llm: Optional[Dict[str, Any]] = None
+    intents: List[Dict[str, Any]] = []
 
 class VersionUpdate(BaseModel):
-    caption: str
-    general_prompt: str
-    llm: Dict[str, Any]
-    intents: List[IntentModel]
-    last_update_date: str
+    caption: Optional[str] = None
+    general_prompt: Optional[str] = None
+    llm: Optional[Dict[str, Any]] = None
+    intents: Optional[List[Dict[str, Any]]] = None
 
 class APICreate(BaseModel):
     name: str
     url: str
-    method: str = "POST"
-    headers: Dict[str, str] = {}
+    method: str = "GET"
+    headers: Dict[str, Any] = {}
     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: 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"
+    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
 
-class TTSRequest(BaseModel):
-    text: str
-    voice_id: Optional[str] = None
-    model_id: Optional[str] = None
-    output_format: Optional[str] = "mp3_44100_128"
+# ===================== Auth Helpers =====================
+def create_token(username: str) -> str:
+    """Create JWT token"""
+    jwt_config = get_jwt_config()
+    
+    payload = {
+        "sub": username,
+        "exp": datetime.now(timezone.utc) + timedelta(hours=jwt_config["expiration_hours"]),
+        "iat": datetime.now(timezone.utc)
+    }
     
-    class Config:
-        protected_namespaces = ()  # Pydantic uyarısını susturmak için
+    return jwt.encode(payload, jwt_config["secret"], algorithm=jwt_config["algorithm"])
 
-# ===================== Helpers =====================
 def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)) -> str:
     """Verify JWT token and return username"""
     jwt_config = get_jwt_config()
     
     try:
         payload = jwt.decode(
-            credentials.credentials, 
-            jwt_config["secret"], 
+            credentials.credentials,
+            jwt_config["secret"],
             algorithms=[jwt_config["algorithm"]]
         )
         username = payload.get("sub")
-        if username is None:
+        if not username:
             raise HTTPException(status_code=401, detail="Invalid token")
         return username
     except jwt.ExpiredSignatureError:
         raise HTTPException(status_code=401, detail="Token expired")
-    except jwt.InvalidTokenError:  # Bu genel JWT hatalarını yakalar
+    except jwt.InvalidTokenError:
         raise HTTPException(status_code=401, detail="Invalid token")
 
-# Utility function to get username for Depends
-get_username = verify_token
-        
-def hash_password(password: str, salt: str = None) -> tuple[str, str]:
-    """Hash password with bcrypt.
-    Returns (hashed_password, salt)"""
-    if salt is None:
-        salt = bcrypt.gensalt().decode('utf-8')
-    
-    # Ensure salt is bytes
-    salt_bytes = salt.encode('utf-8') if isinstance(salt, str) else salt
-    
-    # Hash the password
-    hashed = bcrypt.hashpw(password.encode('utf-8'), salt_bytes)
-    
-    return hashed.decode('utf-8'), salt
-
-def verify_password(password: str, hashed: str, salt: str = None) -> bool:
+def verify_password(plain_password: str, hashed_password: str, salt: str) -> bool:
     """Verify password against hash"""
-    try:
-        # For bcrypt hashes (they contain salt)
-        if hashed.startswith('$2b$') or hashed.startswith('$2a$'):
-            return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
-        
-        # For legacy SHA256 hashes
-        return hashlib.sha256(password.encode()).hexdigest() == hashed
-    except Exception as e:
-        log(f"Password verification error: {e}")
-        return False
-
-def get_timestamp():
-    """Get current timestamp in ISO format with milliseconds"""
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
-
-async def _spark_project_control(action: str, project_name: str, username: str):
-    """Common function for Spark project control"""
-    if not project_name:
-        raise HTTPException(status_code=400, detail="project_name is required")
-    
-    cfg = ConfigProvider.get()
-    spark_endpoint = str(cfg.global_config.spark_endpoint).rstrip("/")
-    spark_token = _get_spark_token()
-    
-    if not spark_endpoint:
-        raise HTTPException(status_code=400, detail="Spark endpoint not configured")
-    
-    if not spark_token:
-        raise HTTPException(status_code=400, detail="Spark token not configured")
-    
-    headers = {
-        "Authorization": f"Bearer {spark_token}",
-        "Content-Type": "application/json"
-    }
-    
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            # Hepsi POST request olarak gönderiliyor
-            response = await client.post(
-                f"{spark_endpoint}/project/{action}",
-                json={"project_name": project_name},
-                headers=headers
-            )
-            
-            response.raise_for_status()
-            return response.json()
-            
-    except httpx.HTTPStatusError as e:
-        error_detail = e.response.json() if e.response.text else {"error": str(e)}
-        raise HTTPException(status_code=e.response.status_code, detail=error_detail)
-    except Exception as e:
-        log(f"❌ Spark {action} failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-def _get_spark_token() -> Optional[str]:
-    """Get Spark token based on work_mode"""
-    cfg = ConfigProvider.get()
-    work_mode = cfg.global_config.work_mode
-    
-    if work_mode in ("hfcloud", "cloud"):
-        # Cloud mode - use HuggingFace Secrets
-        token = os.getenv("SPARK_TOKEN")
-        if not token:
-            log("❌ SPARK_TOKEN not found in HuggingFace Secrets!")
-        return token
-    else:
-        # On-premise mode - use .env file
-        from dotenv import load_dotenv
-        load_dotenv()
-        return os.getenv("SPARK_TOKEN")
-
-async def notify_spark_manual(project: dict, version: dict, global_config: dict):
-    """Manual Spark notification (similar to notify_spark but returns response)"""
-    import httpx
-    
-    spark_endpoint = global_config.get("spark_endpoint", "").rstrip("/")
-    spark_token = _get_spark_token()
-    
-    if not spark_endpoint:
-        raise ValueError("Spark endpoint not configured")
-    
-    if not spark_token:
-        raise ValueError("Spark token not configured")
-    
-    work_mode = global_config.get("work_mode", "hfcloud")
-    cloud_token = global_config.get("cloud_token", "")
-    
-    # Decrypt token if needed
-    if cloud_token and cloud_token.startswith("enc:"):
-        cloud_token = decrypt(cloud_token)
-    
-    payload = {
-        "work_mode": work_mode,
-        "cloud_token": cloud_token,
-        "project_name": project["name"],
-        "project_version": 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"] if version["llm"]["use_fine_tune"] else None
-    }
-    
-    headers = {
-        "Authorization": f"Bearer {spark_token}",
-        "Content-Type": "application/json"
-    }
-    
-    log(f"🚀 Manually notifying Spark about {project['name']} v{version['id']}")
-    
-    async with httpx.AsyncClient(timeout=30) as client:
-        response = await client.post(spark_endpoint + "/startup", json=payload, headers=headers)
-        response.raise_for_status()
-        result = response.json()
-        log(f"✅ Spark manual notification successful: {result.get('message', 'OK')}")
-        return result
-
-# ===================== Auth Endpoints =====================
+    # 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 =====================
 @router.post("/login", response_model=LoginResponse)
 async def login(request: LoginRequest):
-    """Authenticate user and return JWT token"""
+    """User login"""
     cfg = ConfigProvider.get()
-    users = cfg.global_config.users
     
     # Find user
-    user = next((u for u in users if u.username == request.username), None)
+    user = next((u for u in cfg.global_config.users if u.username == request.username), None)
     if not user:
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
@@ -328,15 +185,8 @@ async def login(request: LoginRequest):
     if not verify_password(request.password, user.password_hash, user.salt):
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
-    # Generate JWT token
-    jwt_config = get_jwt_config()
-    
-    payload = {
-        "sub": request.username,
-        "exp": datetime.now(timezone.utc) + timedelta(hours=jwt_config["expiration_hours"])
-    }
-    
-    token = jwt.encode(payload, jwt_config["secret"], algorithm=jwt_config["algorithm"])
+    # Create token
+    token = create_token(request.username)
     
     log(f"✅ User '{request.username}' logged in")
     return LoginResponse(token=token, username=request.username)
@@ -348,10 +198,9 @@ async def change_password(
 ):
     """Change user password"""
     cfg = ConfigProvider.get()
-    users = cfg.global_config.users
     
     # Find user
-    user = next((u for u in users if u.username == username), None)
+    user = next((u for u in cfg.global_config.users if u.username == username), None)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
     
@@ -362,8 +211,12 @@ async def change_password(
     # Hash new password
     new_hash, new_salt = hash_password(request.new_password)
     
-    # Update user via ConfigProvider
-    ConfigProvider.update_user_password(username, new_hash, new_salt)
+    # Update user
+    user.password_hash = new_hash
+    user.salt = new_salt
+    
+    # Save config
+    ConfigProvider._save()
     
     log(f"✅ Password changed for user '{username}'")
     return {"success": True}
@@ -404,17 +257,10 @@ async def get_environment(username: str = Depends(verify_token)):
     env_config = cfg.global_config
     
     return {
-        "work_mode": env_config.work_mode,
-        "cloud_token": env_config.cloud_token or "",
-        "spark_endpoint": str(env_config.spark_endpoint),
-        "internal_prompt": env_config.internal_prompt or "",
-        "tts_engine": env_config.tts_engine,
-        "tts_engine_api_key": env_config.tts_engine_api_key or "",
-        "tts_settings": env_config.get_tts_settings(),
-        "stt_engine": env_config.stt_engine,
-        "stt_engine_api_key": env_config.stt_engine_api_key or "",
-        "stt_settings": env_config.get_stt_settings(),
-        "parameter_collection_config": env_config.parameter_collection_config.model_dump()
+        "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]
     }
 
 @router.put("/environment")
@@ -425,46 +271,43 @@ async def update_environment(
     """Update environment configuration"""
     log(f"📝 Updating environment config by {username}")
     
-    # Token validation based on mode
-    if update.work_mode in ("gpt4o", "gpt4o-mini"):
-        if not update.cloud_token:
-            raise HTTPException(status_code=400, detail="OpenAI API key is required for GPT modes")
-        if not update.cloud_token.startswith("sk-") and not update.cloud_token.startswith("enc:"):
-            raise HTTPException(status_code=400, detail="Invalid OpenAI API key format")
-    elif update.work_mode in ("hfcloud", "cloud"):
-        if not update.cloud_token:
-            raise HTTPException(status_code=400, detail="Cloud token is required for cloud modes")
-
-    # TTS/STT validation
-    if update.tts_engine not in ("no_tts", "elevenlabs", "blaze"):
-        raise HTTPException(status_code=400, detail="Invalid TTS engine")
+    cfg = ConfigProvider.get()
     
-    if update.stt_engine not in ("no_stt", "google", "azure", "amazon", "gpt4o_realtime", "flicker"):
-        raise HTTPException(status_code=400, detail="Invalid STT engine")
+    # Validate LLM provider
+    llm_provider_def = cfg.global_config.get_provider_config("llm", update.llm_provider.name)
+    if not llm_provider_def:
+        raise HTTPException(status_code=400, detail=f"Unknown LLM provider: {update.llm_provider.name}")
     
-    if update.tts_engine != "no_tts" and not update.tts_engine_api_key:
-        raise HTTPException(status_code=400, detail=f"{update.tts_engine} API key is required")
+    # 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}")
     
-    if update.stt_engine != "no_stt" and not update.stt_engine_api_key:
-        raise HTTPException(status_code=400, detail=f"{update.stt_engine} API key or credentials required")
+    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}")
+
+    # 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":
+        raise HTTPException(status_code=400, detail=f"Unknown TTS provider: {update.tts_provider.name}")
     
-    # Spark endpoint validation
-    if update.work_mode not in ("gpt4o", "gpt4o-mini") and not update.spark_endpoint:
-        raise HTTPException(status_code=400, detail="Spark endpoint is required for non-GPT modes")
+    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}")
+    
+    # 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":
+        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}")
     
     # Update via ConfigProvider
     ConfigProvider.update_environment(update.model_dump(), username)
     
-    log(f"✅ Environment updated to {update.work_mode} with TTS: {update.tts_engine}, STT: {update.stt_engine} by {username}")
+    log(f"✅ Environment updated 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,
@@ -480,49 +323,31 @@ 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 with initial version"""
-    # Validate supported languages
-    from locale_manager import LocaleManager
-    
-    invalid_languages = LocaleManager.validate_project_languages(project.supported_languages)
-    if invalid_languages:
-        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 languages: {', '.join(invalid_languages)}. Available languages: {', '.join(available_codes)}"
-        )
-    
-    # Check if default language is in supported languages
-    if not project.supported_languages:
-        raise HTTPException(
-            status_code=400,
-            detail="At least one supported language must be selected"
-        )
-    
-    # Create project via ConfigProvider
+    """Create new project"""
     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,
@@ -530,10 +355,9 @@ async def update_project(
     username: str = Depends(verify_token)
 ):
     """Update project"""
-    # Update via ConfigProvider
-    updated_project = ConfigProvider.update_project(project_id, update.model_dump(), username)
+    updated_project = ConfigProvider.update_project(project_id, update.model_dump(exclude_unset=True), username)
     
-    log(f"✅ Project '{updated_project.name}' updated by {username}")
+    log(f"✅ Project {project_id} updated by {username}")
     return updated_project.model_dump()
 
 @router.delete("/projects/{project_id}")
@@ -541,16 +365,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 deleted by {username}")
+    log(f"✅ Project {project_id} 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"""
-    enabled = ConfigProvider.toggle_project(project_id, username)
+    project = ConfigProvider.toggle_project(project_id, username)
     
-    log(f"✅ Project {'enabled' if enabled else 'disabled'} by {username}")
-    return {"enabled": enabled}
+    log(f"✅ Project {project_id} {'enabled' if project.enabled else 'disabled'} by {username}")
+    return {"success": True, "enabled": project.enabled}
 
 # ===================== Version Endpoints =====================
 @router.get("/projects/{project_id}/versions")
@@ -560,7 +384,9 @@ async def list_versions(
     username: str = Depends(verify_token)
 ):
     """List project versions"""
-    project = ConfigProvider.get_project(project_id)
+    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")
     
@@ -592,7 +418,7 @@ async def update_version(
     username: str = Depends(verify_token)
 ):
     """Update version"""
-    updated_version = ConfigProvider.update_version(project_id, version_id, update.model_dump(), username)
+    updated_version = ConfigProvider.update_version(project_id, version_id, update.model_dump(exclude_unset=True), username)
     
     log(f"✅ Version {version_id} updated for project {project_id} by {username}")
     return updated_version.model_dump()
@@ -608,18 +434,7 @@ async def publish_version(
     
     log(f"✅ Version {version_id} published for project '{project.name}' by {username}")
 
-    # Notify Spark if project is enabled
-    if project.enabled:
-        try:
-            cfg = ConfigProvider.get()
-            await notify_spark_manual(
-                project.model_dump(), 
-                version.model_dump(), 
-                cfg.global_config.model_dump()
-            )
-        except Exception as e:
-            log(f"⚠️ Failed to notify Spark: {e}")
-            # Don't fail the publish 
+    # TODO: Notify LLM provider if needed (only for Spark variants)
 
     return {"success": True}
 
@@ -635,6 +450,43 @@ 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(...),
@@ -695,7 +547,7 @@ async def update_api(
     username: str = Depends(verify_token)
 ):
     """Update API"""
-    updated_api = ConfigProvider.update_api(api_name, update.model_dump(), username)
+    updated_api = ConfigProvider.update_api(api_name, update.model_dump(exclude_unset=True), username)
     
     log(f"✅ API '{api_name}' updated by {username}")
     return updated_api.model_dump()
@@ -707,369 +559,88 @@ async def delete_api(api_name: str, username: str = Depends(verify_token)):
     
     log(f"✅ API '{api_name}' deleted by {username}")
     return {"success": True}
-    
-# ===================== Spark Integration Endpoints =====================
-@router.post("/spark/startup")
-async def spark_startup(request: dict = Body(...), username: str = Depends(verify_token)):
-    """Trigger Spark startup for a project"""
-    project_name = request.get("project_name")
-    if not project_name:
-        raise HTTPException(status_code=400, detail="project_name is required")
-    
-    project = ConfigProvider.get_project_by_name(project_name)
-    if not project:
-        raise HTTPException(status_code=404, detail=f"Project not found: {project_name}")
-    
-    # Find published version
-    version = next((v for v in project.versions if v.published), None)
-    if not version:
-        raise HTTPException(status_code=400, detail=f"No published version found for project: {project_name}")
-    
-    # Notify Spark
-    try:
-        cfg = ConfigProvider.get()
-        result = await notify_spark_manual(
-            project.model_dump(), 
-            version.model_dump(), 
-            cfg.global_config.model_dump()
-        )
-        return {"message": result.get("message", "Spark startup initiated")}
-    except Exception as e:
-        log(f"❌ Spark startup failed: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
 
-@router.get("/spark/projects")
-async def spark_get_projects(username: str = Depends(verify_token)):
-    """Get Spark project list"""
-    cfg = ConfigProvider.get()
-    spark_endpoint = str(cfg.global_config.spark_endpoint).rstrip("/")
-    spark_token = _get_spark_token()
-    
-    if not spark_endpoint:
-        raise HTTPException(status_code=400, detail="Spark endpoint not configured")
-    
-    if not spark_token:
-        raise HTTPException(status_code=400, detail="Spark token not configured")
+@router.post("/apis/test")
+async def test_api(
+    request: dict = Body(...),
+    username: str = Depends(verify_token)
+):
+    """Test API endpoint"""
+    from api_executor import test_api_call
     
-    headers = {
-        "Authorization": f"Bearer {spark_token}"
-    }
+    api_config = request.get("api_config")
+    test_params = request.get("test_params", {})
     
-    try:
-        async with httpx.AsyncClient(timeout=30) as client:
-            response = await client.get(spark_endpoint + "/project/list", headers=headers)
-            response.raise_for_status()
-            return response.json()
-    except Exception as e:
-        log(f"❌ Failed to get Spark projects: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/spark/project/enable")
-async def spark_enable_project(request: dict = Body(...), username: str = Depends(verify_token)):
-    """Enable project in Spark"""
-    return await _spark_project_control("enable", request.get("project_name"), username)
-
-@router.post("/spark/project/disable") 
-async def spark_disable_project(request: dict = Body(...), username: str = Depends(verify_token)):
-    """Disable project in Spark"""
-    return await _spark_project_control("disable", request.get("project_name"), username)
-
-@router.delete("/spark/project/{project_name}")
-async def spark_delete_project(project_name: str, username: str = Depends(verify_token)):
-    """Delete project from Spark"""
-    return await _spark_project_control("delete", project_name, username)
-
-# ===================== Test Endpoints =====================
-@router.post("/apis/test")
-async def test_api(api_data: dict = Body(...), username: str = Depends(verify_token)):
-    """Test API endpoint with auth support"""
-    import requests
-    import time
+    if not api_config:
+        raise HTTPException(status_code=400, detail="API config is required")
     
     try:
-        # Extract test request data if provided
-        test_request = api_data.pop("test_request", None)
-        
-        # Parse the APICreate model
-        api = APICreate(**api_data)
-        
-        # Prepare headers
-        headers = api.headers.copy()
-        
-        # Handle authentication if enabled
-        auth_token = None
-        if api.auth and api.auth.get("enabled"):
-            auth_config = api.auth
-            try:
-                log(f"🔑 Fetching auth token for test...")
-                
-                # Make auth request
-                auth_response = requests.post(
-                    auth_config["token_endpoint"],
-                    json=auth_config.get("token_request_body", {}),
-                    timeout=10
-                )
-                auth_response.raise_for_status()
-                
-                # Extract token from response
-                auth_json = auth_response.json()
-                token_path = auth_config.get("response_token_path", "token").split(".")
-                
-                auth_token = auth_json
-                for path_part in token_path:
-                    auth_token = auth_token.get(path_part)
-                    if auth_token is None:
-                        raise ValueError(f"Token not found at path: {auth_config.get('response_token_path')}")
-                
-                # Add token to headers
-                headers["Authorization"] = f"Bearer {auth_token}"
-                log(f"✅ Auth token obtained: {auth_token[:20]}...")
-                
-            except Exception as e:
-                log(f"❌ Auth failed during test: {e}")
-                return {
-                    "success": False,
-                    "error": f"Authentication failed: {str(e)}"
-                }
-        
-        # Use test_request if provided, otherwise use body_template
-        request_body = test_request if test_request is not None else api.body_template
-        
-        # Make the actual API request
-        start_time = time.time()
-        
-        # Determine how to send the body based on method
-        if api.method in ["POST", "PUT", "PATCH"]:
-            response = requests.request(
-                method=api.method,
-                url=api.url,
-                headers=headers,
-                json=request_body,
-                timeout=api.timeout_seconds,
-                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
-            )
-        elif api.method == "GET":
-            response = requests.request(
-                method=api.method,
-                url=api.url,
-                headers=headers,
-                params=request_body if isinstance(request_body, dict) else None,
-                timeout=api.timeout_seconds,
-                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
-            )
-        else:  # DELETE, HEAD, etc.
-            response = requests.request(
-                method=api.method,
-                url=api.url,
-                headers=headers,
-                timeout=api.timeout_seconds,
-                proxies={"http": api.proxy, "https": api.proxy} if api.proxy else None
-            )
-        
-        response_time = int((time.time() - start_time) * 1000)
-        
-        # Prepare response body
-        try:
-            response_body = response.json()
-        except:
-            response_body = response.text
-        
-        # Check if request was successful (2xx status codes)
-        is_success = 200 <= response.status_code < 300
-        
-        # Extract values if response mappings are defined
-        extracted_values = []
-        if api.response_mappings and isinstance(response_body, dict):
-            from jsonpath_ng import parse
-            for mapping in api.response_mappings:
-                try:
-                    jsonpath_expr = parse(mapping['json_path'])
-                    matches = jsonpath_expr.find(response_body)
-                    value = matches[0].value if matches else None
-                    extracted_values.append({
-                        "variable_name": mapping['variable_name'],
-                        "value": value,
-                        "type": mapping['type'],
-                        "caption": mapping.get('caption', '')
-                    })
-                except Exception as e:
-                    log(f"Failed to extract {mapping['variable_name']}: {e}")
-                    extracted_values.append({
-                        "variable_name": mapping['variable_name'],
-                        "value": None,
-                        "error": str(e),
-                        "type": mapping['type'],
-                        "caption": mapping.get('caption', '')
-                    })
-        
-        result = {
-            "success": is_success,
-            "status_code": response.status_code,
-            "response_time": response_time,
-            "response_body": response_body,
-            "response_headers": dict(response.headers),
-            "request_body": request_body,
-            "request_headers": headers
-        }
-        
-        # Add extracted values if any
-        if extracted_values:
-            result["extracted_values"] = extracted_values
-        
-        # Add error info for non-2xx responses
-        if not is_success:
-            result["error"] = f"HTTP {response.status_code}: {response.reason}"
-        
-        log(f"📋 Test result: {response.status_code} in {response_time}ms")
-        return result
-        
-    except requests.exceptions.Timeout:
-        return {
-            "success": False,
-            "error": f"Request timed out after {api.timeout_seconds} seconds"
-        }
-    except requests.exceptions.ConnectionError as e:
+        result = await test_api_call(api_config, test_params)
         return {
-            "success": False,
-            "error": f"Connection error: {str(e)}"
+            "success": True,
+            "status_code": result.get("status_code"),
+            "response": result.get("response"),
+            "headers": result.get("headers"),
+            "duration_ms": result.get("duration_ms")
         }
     except Exception as e:
-        log(f"❌ Test API error: {e}")
+        log(f"❌ API test failed: {e}")
         return {
             "success": False,
             "error": str(e)
         }
 
-@router.post("/test/run-all")
-async def run_all_tests(
-    request: TestRequest,
+# ===================== 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),
     username: str = Depends(verify_token)
 ):
-    """Run all tests"""
-    # TODO: Implement test runner
+    """Get activity log entries"""
+    # TODO: Implement when activity logging is added
     return {
-        "status": "completed",
-        "total": 10,
-        "passed": 8,
-        "failed": 2,
-        "details": []
+        "entries": [],
+        "total": 0,
+        "limit": limit,
+        "offset": offset
     }
 
-# ===================== Import/Export Endpoints =====================
-@router.post("/projects/import")
-async def import_project(
-    project_data: dict = Body(...),
-    username: str = Depends(verify_token)
-):
-    """Import project from JSON"""
-    imported_project = ConfigProvider.import_project(project_data, username)
-    
-    log(f"✅ Project '{imported_project.name}' imported by {username}")
-    return imported_project.model_dump()
-
-@router.get("/projects/{project_id}/export")
-async def export_project(
-    project_id: int,
-    username: str = Depends(verify_token)
-):
-    """Export project as JSON"""
-    export_data = ConfigProvider.export_project(project_id, username)
-    
-    log(f"✅ Project exported by {username}")
-    return export_data
-
-# ===================== TTS Endpoints =====================
-@router.post("/tts/generate")
-async def generate_tts(
-    request: TTSRequest,
-    username: str = Depends(verify_token)
-):
-    """Generate TTS audio from text"""
-    try:
-        # ConfigProvider'dan güncel config'i al (reload yerine get kullan)
-        cfg = ConfigProvider.get()
-        
-        tts_engine = cfg.global_config.tts_engine
-        log(f"🔧 TTS Engine: {tts_engine}")
-        
-        if tts_engine == "no_tts":
-            raise HTTPException(status_code=400, detail="TTS is not configured")
-        
-        # Get decrypted API key
-        api_key = cfg.global_config.get_tts_api_key()
-        
-        if not api_key:
-            log("❌ TTS API key not found in config")
-            raise HTTPException(status_code=400, detail="TTS API key not configured")
-        
-        # Import here to avoid circular dependency
-        from tts_interface import create_tts_provider
-        
-        tts_provider = create_tts_provider(tts_engine, api_key)
-        if not tts_provider:
-            raise HTTPException(status_code=500, detail="Failed to create TTS provider")
-        
-        log(f"🎤 Generating TTS for {len(request.text)} characters using {tts_engine}")
-        log(f"📝 Voice: {request.voice_id}, Model: {request.model_id}, Format: {request.output_format}")
-        
-        # Generate audio
-        audio_data = await tts_provider.synthesize(
-            text=request.text,
-            voice_id=request.voice_id,
-            model_id=request.model_id,
-            output_format=request.output_format
-        )
-        
-        # Return audio data
-        from fastapi.responses import Response
-        
-        content_type = "audio/mpeg" if request.output_format and request.output_format.startswith("mp3") else "audio/wav"
-        
-        return Response(
-            content=audio_data,
-            media_type=content_type,
-            headers={
-                "Content-Disposition": f"attachment; filename=tts_output.{request.output_format.split('_')[0] if request.output_format else 'mp3'}"
-            }
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        log(f"❌ TTS generation error: {str(e)}")
-        import traceback
-        log(traceback.format_exc())
-        raise HTTPException(status_code=500, detail=f"TTS generation failed: {str(e)}")
-
-        
-# ===================== Activity Log Endpoints =====================
-@router.get("/activity-log")
-async def get_activity_log(
-    limit: int = Query(100, ge=1, le=1000),
-    username: str = Depends(verify_token)
-):
-    """Get activity log"""
-    cfg = ConfigProvider.get()
-    logs = cfg.activity_log
-    
-    # Return latest entries
-    return [log.model_dump() for log in logs[-limit:]]
+# ===================== Health Check =====================
+@router.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "ok",
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+        "version": "1.0.0"
+    }
 
 # ===================== Cleanup Task =====================
-def cleanup_old_logs():
-    """Cleanup old activity logs (runs in background)"""
+_cleanup_thread = None
+
+def cleanup_activity_logs():
+    """Cleanup old activity logs periodically"""
     while True:
         try:
-            ConfigProvider.cleanup_activity_logs()
-            log("🧹 Cleaned up old activity logs")
+            # Sleep for 24 hours
+            time.sleep(86400)
+            
+            # TODO: Implement cleanup logic when activity logging is added
+            log("🧹 Running activity log cleanup...")
+            
         except Exception as e:
-            log(f"Error in cleanup task: {e}")
-        
-        # Run every hour
-        time.sleep(3600)
+            log(f"❌ Cleanup error: {e}")
 
 def start_cleanup_task():
-    """Start cleanup task in background"""
-    cleanup_thread = threading.Thread(target=cleanup_old_logs, daemon=True)
-    cleanup_thread.start()
-    log("🧹 Started activity log 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"