diff --git a/internal/admin/enterprise_handler.go b/internal/admin/enterprise_handler.go
index 2650174664..231840fa33 100644
--- a/internal/admin/enterprise_handler.go
+++ b/internal/admin/enterprise_handler.go
@@ -31,7 +31,7 @@ import (
 func (h *Handler) ListRoles(c *gin.Context) {
 	roles, err := h.service.ListRoles()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -52,13 +52,13 @@ type CreateRoleHTTPRequest struct {
 func (h *Handler) CreateRole(c *gin.Context) {
 	var req CreateRoleHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	role, err := h.service.CreateRole(req.RoleName, req.Description)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -69,13 +69,13 @@ func (h *Handler) CreateRole(c *gin.Context) {
 func (h *Handler) ShowRole(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	role, err := h.service.ShowRole(roleName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -91,19 +91,19 @@ type UpdateRoleHTTPRequest struct {
 func (h *Handler) UpdateRole(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	var req UpdateRoleHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Role description is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role description is required")
 		return
 	}
 
 	role, err := h.service.UpdateRole(roleName, req.Description)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -114,13 +114,13 @@ func (h *Handler) UpdateRole(c *gin.Context) {
 func (h *Handler) DropRole(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	role, err := h.service.DropRole(roleName)
 	if err != nil {
-		common.ErrorWithCode(c, 404, "Role not found")
+		common.ErrorWithCode(c, common.CodeNotFound, "Role not found")
 		return
 	}
 
@@ -131,13 +131,13 @@ func (h *Handler) DropRole(c *gin.Context) {
 func (h *Handler) ShowRolePermission(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	permissions, err := h.service.ShowRolePermission(roleName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -154,19 +154,19 @@ type GrantRolePermissionHTTPRequest struct {
 func (h *Handler) GrantRolePermission(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	var req GrantRolePermissionHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Permission is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Permission is required")
 		return
 	}
 
 	result, err := h.service.GrantRolePermission(roleName, req.Actions, req.Resource)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -183,19 +183,19 @@ type RevokeRolePermissionHTTPRequest struct {
 func (h *Handler) RevokeRolePermission(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	var req RevokeRolePermissionHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Permission is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Permission is required")
 		return
 	}
 
 	result, err := h.service.RevokeRolePermission(roleName, req.Actions, req.Resource)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -207,10 +207,10 @@ func (h *Handler) ListResources(c *gin.Context) {
 	resources, err := h.service.ListResources()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "Role not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "Role not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -220,13 +220,13 @@ func (h *Handler) ListResources(c *gin.Context) {
 func (h *Handler) ShowRoleDefaultModels(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	result, err := h.service.ShowRoleDefaultModels(roleName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 	common.SuccessWithData(c, result, "Role default model set successfully")
@@ -240,7 +240,7 @@ type SetRoleDefaultModelRequest struct {
 func (h *Handler) SetRoleDefaultModel(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
@@ -251,7 +251,7 @@ func (h *Handler) SetRoleDefaultModel(c *gin.Context) {
 
 	result, err := h.service.SetRoleDefaultModel(roleName, request.ModelID, request.ModelType)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 	common.SuccessWithData(c, result, "Role default model set successfully")
@@ -264,7 +264,7 @@ type ResetRoleDefaultModelRequest struct {
 func (h *Handler) ResetRoleDefaultModel(c *gin.Context) {
 	roleName := c.Param("role_name")
 	if roleName == "" {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
@@ -276,7 +276,7 @@ func (h *Handler) ResetRoleDefaultModel(c *gin.Context) {
 
 	result, err := h.service.ResetRoleDefaultModel(roleName, request.ModelType)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 	common.SuccessWithData(c, result, "Role default model set successfully")
@@ -294,7 +294,7 @@ func (h *Handler) ListModelProviders(c *gin.Context) {
 
 	result, err := h.service.ListModelProviders()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -316,7 +316,7 @@ func (h *Handler) AddModelProvider(c *gin.Context) {
 
 	result, err := h.service.AddModelProvider(req.ProviderName, userID)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -353,7 +353,7 @@ func (h *Handler) DeleteModelProvider(c *gin.Context) {
 
 	result, err := h.service.DeleteModelProviders(userID, req.ProviderNames)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -405,7 +405,7 @@ func (h *Handler) ListModelInstances(c *gin.Context) {
 
 	result, err := h.service.ListModelInstances(userID, providerName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -427,7 +427,7 @@ func (h *Handler) ShowProviderInstance(c *gin.Context) {
 
 	result, err := h.service.ShowProviderInstance(userID, providerName, instanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -449,7 +449,7 @@ func (h *Handler) ShowProviderInstanceBalance(c *gin.Context) {
 
 	result, err := h.service.ShowProviderInstanceBalance(userID, providerName, instanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -471,7 +471,7 @@ func (h *Handler) CheckInstanceConnection(c *gin.Context) {
 
 	result, err := h.service.CheckInstanceConnection(userID, providerName, instanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -501,7 +501,7 @@ func (h *Handler) CheckProviderConnection(c *gin.Context) {
 
 	result, err := h.service.CheckProviderConnection(userID, providerName, req.Region, req.APIKey, req.BaseURL)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -540,7 +540,7 @@ func (h *Handler) AlterProviderInstance(c *gin.Context) {
 
 	result, err := h.service.AlterProviderInstance(userID, providerName, instanceName, req.InstanceName, req.APIKey)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -568,7 +568,7 @@ func (h *Handler) AddModelInstance(c *gin.Context) {
 
 	result, err := h.service.AddModelInstance(userID, providerName, req.InstanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -596,7 +596,7 @@ func (h *Handler) DeleteModelInstance(c *gin.Context) {
 
 	result, err := h.service.DeleteModelInstances(userID, providerName, req.InstanceNames)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -620,7 +620,7 @@ func (h *Handler) ListInstanceModels(c *gin.Context) {
 
 	result, err := h.service.ListInstanceModels(userID, providerName, instanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -664,7 +664,7 @@ func (h *Handler) EnableOrDisableModel(c *gin.Context) {
 
 	result, err := h.service.EnableOrDisableModel(userID, providerName, instanceName, modelName, modelID, req.Status)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -698,7 +698,7 @@ func (h *Handler) AddModels(c *gin.Context) {
 
 	result, err := h.service.AddModels(userID, providerName, instanceName, req.ModelNames)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -732,7 +732,7 @@ func (h *Handler) DeleteModels(c *gin.Context) {
 
 	result, err := h.service.DeleteModels(userID, providerName, instanceName, req.ModelNames)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -743,7 +743,7 @@ func (h *Handler) DeleteModels(c *gin.Context) {
 func (h *Handler) GetSystemFingerprint(c *gin.Context) {
 	fingerprint, err := h.service.GetSystemFingerprint()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -765,7 +765,7 @@ func (h *Handler) SetSystemLicense(c *gin.Context) {
 
 	err := h.service.SetSystemLicense(req.License)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 	common.SuccessWithData(c, nil, "System license set successfully")
@@ -779,12 +779,12 @@ func (h *Handler) ShowSystemLicense(c *gin.Context) {
 	}
 	checkFlag, err := strconv.ParseBool(check)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	systemLicense, err := h.service.ShowSystemLicense(checkFlag)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -805,7 +805,7 @@ func (h *Handler) UpdateSystemLicenseConfig(c *gin.Context) {
 	}
 	result, err := h.service.UpdateSystemLicenseConfig(req.TimeRecordSaveInterval, req.TimeRecordTaskDuration)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 	common.SuccessWithData(c, result, "System license config updated successfully")
@@ -827,10 +827,10 @@ func (h *Handler) ShowUserActivity(c *gin.Context) {
 	userActivity, err := h.service.ShowUserActivity(req.Email, req.Days)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -853,21 +853,21 @@ func (h *Handler) ShowUserDatasetSummary(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userDatasetSummary, err := h.service.ShowUserDatasetSummary(username, req.Dataset)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -879,21 +879,21 @@ func (h *Handler) ShowUserSummary(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userSummary, err := h.service.ShowUserSummary(username)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -905,21 +905,21 @@ func (h *Handler) ShowUserStorage(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userStorage, err := h.service.ShowUserStorage(username)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -931,21 +931,21 @@ func (h *Handler) ShowUserQuota(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userQuota, err := h.service.ShowUserQuota(username)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -957,21 +957,21 @@ func (h *Handler) ShowUserIndex(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userIndex, err := h.service.ShowUserIndex(username)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -988,23 +988,23 @@ func (h *Handler) UpdateUserRole(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	var req UpdateUserRoleHTTPRequest
 	if err = c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Role name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Role name is required")
 		return
 	}
 
 	result, err := h.service.UpdateUserRole(username, req.RoleName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1016,17 +1016,17 @@ func (h *Handler) ShowUserPermission(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	permissions, err := h.service.ShowUserPermission(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1038,17 +1038,17 @@ func (h *Handler) ListUserDatasets(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	datasets, err := h.service.ListUserDatasets(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1060,17 +1060,17 @@ func (h *Handler) ListUserAgents(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	agents, err := h.service.ListUserAgents(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1082,17 +1082,17 @@ func (h *Handler) ListUserChats(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	chats, err := h.service.ListUserChats(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1104,17 +1104,17 @@ func (h *Handler) ListUserSearches(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	searches, err := h.service.ListUserSearches(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1126,17 +1126,17 @@ func (h *Handler) ListUserModels(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	models, err := h.service.ListUserModels(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1148,17 +1148,17 @@ func (h *Handler) ListUserFiles(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	files, err := h.service.ListUserFiles(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1170,17 +1170,17 @@ func (h *Handler) ListUserProviders(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	providers, err := h.service.ListUserProviders(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1192,23 +1192,23 @@ func (h *Handler) ListUserProviderInstances(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	userName, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if userName == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	providerName := c.Param("provider_name")
 	if providerName == "" {
-		common.ErrorWithCode(c, 400, "Provider name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Provider name is required")
 		return
 	}
 
 	instances, err := h.service.ListUserProviderInstances(userName, providerName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1220,29 +1220,29 @@ func (h *Handler) ListUserProviderInstanceModels(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	userName, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if userName == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	providerName := c.Param("provider_name")
 	if providerName == "" {
-		common.ErrorWithCode(c, 400, "Provider name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Provider name is required")
 		return
 	}
 
 	instanceName := c.Param("instance_name")
 	if instanceName == "" {
-		common.ErrorWithCode(c, 400, "Instance name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Instance name is required")
 		return
 	}
 
 	models, err := h.service.ListUserProviderInstanceModels(userName, providerName, instanceName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1254,17 +1254,17 @@ func (h *Handler) ListUserDefaultModels(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	userName, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if userName == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	models, err := h.service.ListUserDefaultModels(userName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1276,10 +1276,10 @@ func (h *Handler) ShowUsersSummary(c *gin.Context) {
 	usersSummary, err := h.service.ShowUsersSummary()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1302,10 +1302,10 @@ func (h *Handler) ShowUsersActivity(c *gin.Context) {
 	usersActivity, err := h.service.ShowUsersActivity(req.Days, req.Window)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1333,7 +1333,7 @@ func (h *Handler) ListUsersReports(c *gin.Context) {
 	if pageIndexStr != "" {
 		pageIndex, err = strconv.Atoi(pageIndexStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page index must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page index must be an integer")
 			return
 		}
 	}
@@ -1342,7 +1342,7 @@ func (h *Handler) ListUsersReports(c *gin.Context) {
 	if pageSizeStr != "" {
 		pageSize, err = strconv.Atoi(pageSizeStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -1350,10 +1350,10 @@ func (h *Handler) ListUsersReports(c *gin.Context) {
 	usersReports, err := h.service.ListUsersReports(pageIndex, pageSize, req.Status, req.Plan, req.Days)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1369,7 +1369,7 @@ func (h *Handler) ListUsersStorage(c *gin.Context) {
 	if pageIndexStr != "" {
 		pageIndex, err = strconv.Atoi(pageIndexStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page index must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page index must be an integer")
 			return
 		}
 	}
@@ -1378,7 +1378,7 @@ func (h *Handler) ListUsersStorage(c *gin.Context) {
 	if pageSizeStr != "" {
 		pageSize, err = strconv.Atoi(pageSizeStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -1387,17 +1387,17 @@ func (h *Handler) ListUsersStorage(c *gin.Context) {
 	if topStr != "" {
 		top, err = strconv.Atoi(topStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Top must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Top must be an integer")
 		}
 	}
 
 	usersStorage, err := h.service.ListUsersStorage(pageIndex, pageSize, top)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1413,7 +1413,7 @@ func (h *Handler) ListUsersDocuments(c *gin.Context) {
 	if pageIndexStr != "" {
 		pageIndex, err = strconv.Atoi(pageIndexStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page index must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page index must be an integer")
 			return
 		}
 	}
@@ -1422,7 +1422,7 @@ func (h *Handler) ListUsersDocuments(c *gin.Context) {
 	if pageSizeStr != "" {
 		pageSize, err = strconv.Atoi(pageSizeStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -1431,17 +1431,17 @@ func (h *Handler) ListUsersDocuments(c *gin.Context) {
 	if topStr != "" {
 		top, err = strconv.Atoi(topStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Top must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Top must be an integer")
 		}
 	}
 
 	usersDocuments, err := h.service.ListUsersDocuments(pageIndex, pageSize, top)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1457,7 +1457,7 @@ func (h *Handler) ListUsersIndex(c *gin.Context) {
 	if pageIndexStr != "" {
 		pageIndex, err = strconv.Atoi(pageIndexStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page index must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page index must be an integer")
 			return
 		}
 	}
@@ -1466,7 +1466,7 @@ func (h *Handler) ListUsersIndex(c *gin.Context) {
 	if pageSizeStr != "" {
 		pageSize, err = strconv.Atoi(pageSizeStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -1475,17 +1475,17 @@ func (h *Handler) ListUsersIndex(c *gin.Context) {
 	if topStr != "" {
 		top, err = strconv.Atoi(topStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Top must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Top must be an integer")
 		}
 	}
 
 	usersIndex, err := h.service.ListUsersIndex(pageIndex, pageSize, top)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1513,7 +1513,7 @@ func (h *Handler) ListUsersQuota(c *gin.Context) {
 	if pageIndexStr != "" {
 		pageIndex, err = strconv.Atoi(pageIndexStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page index must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page index must be an integer")
 			return
 		}
 	}
@@ -1522,7 +1522,7 @@ func (h *Handler) ListUsersQuota(c *gin.Context) {
 	if pageSizeStr != "" {
 		pageSize, err = strconv.Atoi(pageSizeStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -1531,17 +1531,17 @@ func (h *Handler) ListUsersQuota(c *gin.Context) {
 	if topStr != "" {
 		top, err = strconv.Atoi(topStr)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Top must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Top must be an integer")
 		}
 	}
 
 	usersQuota, err := h.service.ListUsersQuota(pageIndex, pageSize, top, request.QuotaThreshold, request.Plan, request.Days)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1553,10 +1553,10 @@ func (h *Handler) ShowUsersPlanSummary(c *gin.Context) {
 	usersPlanSummary, err := h.service.ShowUsersPlanSummary()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1568,10 +1568,10 @@ func (h *Handler) ShowUsersQuotaSummary(c *gin.Context) {
 	usersQuotaSummary, err := h.service.ShowUsersQuotaSummary()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1583,10 +1583,10 @@ func (h *Handler) ShowIngestionTasksSummary(c *gin.Context) {
 	ingestionTasksSummary, err := h.service.ShowIngestionTasksSummary()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1598,10 +1598,10 @@ func (h *Handler) ShowDataSummary(c *gin.Context) {
 	dataSummary, err := h.service.ShowDataSummary()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1613,10 +1613,10 @@ func (h *Handler) ShowDataOrphan(c *gin.Context) {
 	dataOrphan, err := h.service.ShowDataOrphan()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1628,10 +1628,10 @@ func (h *Handler) ShowDataStorage(c *gin.Context) {
 	dataStorage, err := h.service.ShowDataStorage()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1643,10 +1643,10 @@ func (h *Handler) ShowDataIndex(c *gin.Context) {
 	dataIndex, err := h.service.ShowDataIndex()
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1668,10 +1668,10 @@ func (h *Handler) PurgeOrphanData(c *gin.Context) {
 	result, err := h.service.PurgeOrphanData(request.Preview)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1693,21 +1693,21 @@ func (h *Handler) PurgeUserData(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	result, err := h.service.PurgeUserData(username, request.Preview)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1733,10 +1733,10 @@ func (h *Handler) PurgeUsersData(c *gin.Context) {
 	result, err := h.service.PurgeUsersData(request.Preview, request.Days, request.Plan, request.UserStatus)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1748,13 +1748,13 @@ func (h *Handler) GenerateUserAPIKey(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
 	apiKey, err := h.service.GenerateUserAPIKey(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1766,18 +1766,18 @@ func (h *Handler) DeleteUserAPIKey(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	key := c.Param("key")
 	if username == "" || key == "" {
-		common.ErrorWithCode(c, 400, "Username and key are required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username and key are required")
 		return
 	}
 
 	result, err := h.service.DeleteUserAPIKey(username, key)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1789,17 +1789,17 @@ func (h *Handler) ListUserAPIKeys(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	result, err := h.service.ListUserAPIKeys(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
diff --git a/internal/admin/handler.go b/internal/admin/handler.go
index 83813c2183..6b7cd90448 100644
--- a/internal/admin/handler.go
+++ b/internal/admin/handler.go
@@ -122,12 +122,12 @@ func (h *Handler) Login(c *gin.Context) {
 func (h *Handler) Logout(c *gin.Context) {
 	user, exists := c.Get("user")
 	if !exists {
-		common.ErrorWithCode(c, 401, "Not authenticated")
+		common.ErrorWithCode(c, common.CodeUnauthorized, "Not authenticated")
 		return
 	}
 
 	if err := h.service.Logout(user); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -161,7 +161,7 @@ func (h *Handler) ListUsers(c *gin.Context) {
 	} else {
 		pageInt, err = strconv.Atoi(page)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page must be an integer")
 			return
 		}
 	}
@@ -173,7 +173,7 @@ func (h *Handler) ListUsers(c *gin.Context) {
 	} else {
 		pageSizeInt, err = strconv.Atoi(pageSize)
 		if err != nil {
-			common.ErrorWithCode(c, 400, "Page size must be an integer")
+			common.ErrorWithCode(c, common.CodeBadRequest, "Page size must be an integer")
 			return
 		}
 	}
@@ -183,7 +183,7 @@ func (h *Handler) ListUsers(c *gin.Context) {
 	if err = c.ShouldBindJSON(&req); err != nil {
 		users, err = h.service.ListUsers(pageInt, pageSizeInt)
 		if err != nil {
-			common.ErrorWithCode(c, 500, err.Error())
+			common.ErrorWithCode(c, common.CodeServerError, err.Error())
 			return
 		}
 
@@ -191,7 +191,7 @@ func (h *Handler) ListUsers(c *gin.Context) {
 	} else {
 		users, err = h.service.ListUsersEnterprise(pageInt, pageSizeInt, req.UserStatus, req.OrderBy, req.Plan, req.Top, req.Days, req.Quota)
 		if err != nil {
-			common.ErrorWithCode(c, 500, err.Error())
+			common.ErrorWithCode(c, common.CodeServerError, err.Error())
 			return
 		}
 
@@ -211,7 +211,7 @@ type CreateUserHTTPRequest struct {
 func (h *Handler) CreateUser(c *gin.Context) {
 	var req CreateUserHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Username and password are required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username and password are required")
 		return
 	}
 
@@ -221,7 +221,7 @@ func (h *Handler) CreateUser(c *gin.Context) {
 
 	userInfo, err := h.service.CreateUser(req.Username, req.Password, req.Role)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -233,21 +233,21 @@ func (h *Handler) GetUser(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	userDetails, err := h.service.GetUserDetails(username)
 	if err != nil {
 		if errors.Is(err, common.ErrUserNotFound) {
-			common.ErrorWithCode(c, 404, "User not found")
+			common.ErrorWithCode(c, common.CodeNotFound, "User not found")
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -259,17 +259,17 @@ func (h *Handler) DeleteUser(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	result, err := h.service.DeleteUser(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -291,22 +291,22 @@ func (h *Handler) ChangePassword(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	var req ChangePasswordHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "New password is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "New password is required")
 		return
 	}
 
 	if err := h.service.ChangePassword(username, req.NewPassword); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -323,28 +323,28 @@ func (h *Handler) UpdateUserActivateStatus(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	var req UpdateActivateStatusHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Activation status is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Activation status is required")
 		return
 	}
 
 	if req.ActivateStatus != "on" && req.ActivateStatus != "off" {
-		common.ErrorWithCode(c, 400, "Activation status must be 'on' or 'off'")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Activation status must be 'on' or 'off'")
 		return
 	}
 
 	isActive := req.ActivateStatus == "on"
 	if err := h.service.UpdateUserActivateStatus(username, isActive); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -356,23 +356,23 @@ func (h *Handler) GrantAdmin(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	// Get current user email from context
 	email, _ := c.Get("email")
 	if email != nil && email.(string) == username {
-		common.ErrorWithCode(c, 409, "can't grant current user: "+username)
+		common.ErrorWithCode(c, common.CodeConflict, "can't grant current user: "+username)
 		return
 	}
 
 	if err := h.service.GrantAdmin(username); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -384,23 +384,23 @@ func (h *Handler) RevokeAdmin(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	// Get current user email from context
 	email, _ := c.Get("email")
 	if email != nil && email.(string) == username {
-		common.ErrorWithCode(c, 409, "can't revoke current user: "+username)
+		common.ErrorWithCode(c, common.CodeConflict, "can't revoke current user: "+username)
 		return
 	}
 
 	if err = h.service.RevokeAdmin(username); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -412,17 +412,17 @@ func (h *Handler) ListUserAPITokens(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	apiKeys, err := h.service.ListUserAPITokens(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -434,17 +434,17 @@ func (h *Handler) GenerateUserAPIToken(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if username == "" {
-		common.ErrorWithCode(c, 400, "Username is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username is required")
 		return
 	}
 
 	apiKey, err := h.service.GenerateUserAPIToken(username)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -456,17 +456,17 @@ func (h *Handler) DeleteUserAPIToken(c *gin.Context) {
 	encodedUsername := c.Param("username")
 	username, err := common.DecodeFromBase64(encodedUsername)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	key := c.Param("token")
 	if username == "" || key == "" {
-		common.ErrorWithCode(c, 400, "Username and key are required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Username and key are required")
 		return
 	}
 
 	if err = h.service.DeleteUserAPIToken(username, key); err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -488,13 +488,13 @@ func (h *Handler) GetServices(c *gin.Context) {
 func (h *Handler) GetServicesByType(c *gin.Context) {
 	serviceType := c.Param("service_type")
 	if serviceType == "" {
-		common.ErrorWithCode(c, 400, "Service type is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Service type is required")
 		return
 	}
 
 	services, err := h.service.GetServicesByType(serviceType)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -505,7 +505,7 @@ func (h *Handler) GetServicesByType(c *gin.Context) {
 func (h *Handler) GetService(c *gin.Context) {
 	serviceID := c.Param("service_id")
 	if serviceID == "" {
-		common.ErrorWithCode(c, 400, "Service ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Service ID is required")
 		return
 	}
 
@@ -523,13 +523,13 @@ func (h *Handler) GetService(c *gin.Context) {
 	}
 
 	if targetService == nil {
-		common.ErrorWithCode(c, 404, "Service not found")
+		common.ErrorWithCode(c, common.CodeNotFound, "Service not found")
 		return
 	}
 
 	serviceStatus, err := h.service.GetServiceDetails(targetService)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -540,13 +540,13 @@ func (h *Handler) GetService(c *gin.Context) {
 func (h *Handler) ShutdownService(c *gin.Context) {
 	serviceID := c.Param("service_id")
 	if serviceID == "" {
-		common.ErrorWithCode(c, 400, "Service ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Service ID is required")
 		return
 	}
 
 	result, err := h.service.ShutdownService(serviceID)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -557,13 +557,13 @@ func (h *Handler) ShutdownService(c *gin.Context) {
 func (h *Handler) StartService(c *gin.Context) {
 	serviceID := c.Param("service_id")
 	if serviceID == "" {
-		common.ErrorWithCode(c, 400, "Service ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Service ID is required")
 		return
 	}
 
 	result, err := h.service.StartService(serviceID)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -574,13 +574,13 @@ func (h *Handler) StartService(c *gin.Context) {
 func (h *Handler) RestartService(c *gin.Context) {
 	serviceID := c.Param("service_id")
 	if serviceID == "" {
-		common.ErrorWithCode(c, 400, "Service ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Service ID is required")
 		return
 	}
 
 	result, err := h.service.RestartService(serviceID)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -594,7 +594,7 @@ func (h *Handler) ListVariables(c *gin.Context) {
 		// List all variables
 		variables, err := h.service.ListAllVariables()
 		if err != nil {
-			common.ErrorWithCode(c, 500, err.Error())
+			common.ErrorWithCode(c, common.CodeServerError, err.Error())
 			return
 		}
 		common.SuccessWithData(c, variables, "")
@@ -606,12 +606,12 @@ func (h *Handler) ListVariables(c *gin.Context) {
 		VarName string `json:"var_name"`
 	}
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Invalid request body")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Invalid request body")
 		return
 	}
 
 	if req.VarName == "" {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
@@ -619,10 +619,10 @@ func (h *Handler) ListVariables(c *gin.Context) {
 	if err != nil {
 		// Check if it's an AdminException
 		if adminErr, ok := err.(*AdminException); ok {
-			common.ErrorWithCode(c, 400, adminErr.Message)
+			common.ErrorWithCode(c, common.CodeBadRequest, adminErr.Message)
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -634,17 +634,17 @@ func (h *Handler) ShowVariable(c *gin.Context) {
 	encodedVarName := c.Param("var_name")
 	varName, err := common.DecodeFromBase64(encodedVarName)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if varName == "" {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	variable, err := h.service.GetVariable(varName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -662,27 +662,27 @@ type SetVariableHTTPRequest struct {
 func (h *Handler) SetVariable(c *gin.Context) {
 	var req SetVariableHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	if req.VarName == "" {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	if req.VarValue == "" {
-		common.ErrorWithCode(c, 400, "Var value is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var value is required")
 		return
 	}
 
 	if err := h.service.SetVariable(req.VarName, req.VarValue); err != nil {
 		// Check if it's an AdminException
 		if adminErr, ok := err.(*AdminException); ok {
-			common.ErrorWithCode(c, 400, adminErr.Message)
+			common.ErrorWithCode(c, common.CodeBadRequest, adminErr.Message)
 			return
 		}
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -693,7 +693,7 @@ func (h *Handler) SetVariable(c *gin.Context) {
 func (h *Handler) ListConfigs(c *gin.Context) {
 	configs, err := h.service.ListAllConfigs()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -704,7 +704,7 @@ func (h *Handler) ListConfigs(c *gin.Context) {
 func (h *Handler) ListEnvironments(c *gin.Context) {
 	environments, err := h.service.ListEnvironments()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -753,7 +753,7 @@ func (h *Handler) ShowLicense(c *gin.Context) {
 func (h *Handler) ListSandboxProviders(c *gin.Context) {
 	providers, err := h.service.ListSandboxProviders()
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -764,13 +764,13 @@ func (h *Handler) ListSandboxProviders(c *gin.Context) {
 func (h *Handler) GetSandboxProviderSchema(c *gin.Context) {
 	providerID := c.Param("provider_id")
 	if providerID == "" {
-		common.ErrorWithCode(c, 400, "Provider ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Provider ID is required")
 		return
 	}
 
 	schema, err := h.service.GetSandboxProviderSchema(providerID)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -781,7 +781,7 @@ func (h *Handler) GetSandboxProviderSchema(c *gin.Context) {
 func (h *Handler) GetSandboxConfig(c *gin.Context) {
 	config, err := h.service.GetSandboxConfig()
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -799,12 +799,12 @@ type SetSandboxConfigHTTPRequest struct {
 func (h *Handler) SetSandboxConfig(c *gin.Context) {
 	var req SetSandboxConfigHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Request body is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Request body is required")
 		return
 	}
 
 	if req.ProviderType == "" {
-		common.ErrorWithCode(c, 400, "Provider type is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Provider type is required")
 		return
 	}
 
@@ -814,7 +814,7 @@ func (h *Handler) SetSandboxConfig(c *gin.Context) {
 
 	result, err := h.service.SetSandboxConfig(req.ProviderType, req.Config, req.SetActive)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -831,12 +831,12 @@ type TestSandboxConnectionHTTPRequest struct {
 func (h *Handler) TestSandboxConnection(c *gin.Context) {
 	var req TestSandboxConnectionHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Request body is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Request body is required")
 		return
 	}
 
 	if req.ProviderType == "" {
-		common.ErrorWithCode(c, 400, "Provider type is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Provider type is required")
 		return
 	}
 
@@ -855,7 +855,7 @@ func (h *Handler) AuthMiddleware() gin.HandlerFunc {
 	return func(c *gin.Context) {
 		token := c.GetHeader("Authorization")
 		if token == "" {
-			common.ErrorWithCode(c, 401, "Missing authorization header")
+			common.ErrorWithCode(c, common.CodeUnauthorized, "Missing authorization header")
 			c.Abort()
 			return
 		}
@@ -901,12 +901,12 @@ type SetLogLevelRequest struct {
 func (h *Handler) SetLogLevel(c *gin.Context) {
 	var req SetLogLevelRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Level is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Level is required")
 		return
 	}
 
 	if err := common.SetLevel(req.Level); err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -918,7 +918,7 @@ func (h *Handler) ListMessagesFromQueue(c *gin.Context) {
 	msgQueueEngine := engine.GetMessageQueueEngine()
 	messages, err := msgQueueEngine.ListMessages("ingestion", false)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	var result []map[string]string
@@ -945,7 +945,7 @@ type PublishMessageToQueueRequest struct {
 func (h *Handler) PublishMessageToQueue(c *gin.Context) {
 	var req PublishMessageToQueueRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Message is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Message is required")
 		return
 	}
 
@@ -957,14 +957,14 @@ func (h *Handler) PublishMessageToQueue(c *gin.Context) {
 	// convert task
 	taskMessageStr, err := json.Marshal(taskMessage)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
 	msgQueueEngine := engine.GetMessageQueueEngine()
 	err = msgQueueEngine.PublishTask("tasks.RAGFLOW", taskMessageStr)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -979,14 +979,14 @@ type PullMessageFromQueueRequest struct {
 func (h *Handler) PullMessageFromQueue(c *gin.Context) {
 	var req PullMessageFromQueueRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, fmt.Sprintf("Message count error: %s", err.Error()))
+		common.ErrorWithCode(c, common.CodeBadRequest, fmt.Sprintf("Message count error: %s", err.Error()))
 		return
 	}
 
 	msgQueueEngine := engine.GetMessageQueueEngine()
 	err := msgQueueEngine.InitConsumer("tasks.RAGFLOW")
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	messages, err := msgQueueEngine.GetMessages(req.MessageCount)
@@ -1030,7 +1030,7 @@ func (h *Handler) ShowMessageQueue(c *gin.Context) {
 	msgQueueEngine := engine.GetMessageQueueEngine()
 	result, err := msgQueueEngine.ShowMessageQueue()
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
@@ -1046,14 +1046,14 @@ type RemoveIngestionTaskRequest struct {
 func (h *Handler) RemoveIngestionTasks(c *gin.Context) {
 	var req RemoveIngestionTaskRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Task ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Task ID is required")
 		return
 	}
 
 	if req.Email == nil && req.Status == nil {
 		tasks, err := h.service.RemoveIngestionTasks(req.Tasks)
 		if err != nil {
-			common.ErrorWithCode(c, 400, err.Error())
+			common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 			return
 		}
 
@@ -1061,7 +1061,7 @@ func (h *Handler) RemoveIngestionTasks(c *gin.Context) {
 	} else {
 		tasks, err := h.service.RemoveIngestionTasksByCondition(req.Tasks, req.Email, req.Status)
 		if err != nil {
-			common.ErrorWithCode(c, 400, err.Error())
+			common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 			return
 		}
 		common.SuccessWithData(c, tasks, "Remove tasks successfully")
@@ -1077,14 +1077,14 @@ type StopIngestionTaskRequest struct {
 func (h *Handler) StopIngestionTasks(c *gin.Context) {
 	var req StopIngestionTaskRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Task ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Task ID is required")
 		return
 	}
 
 	if req.Email == nil && req.Status == nil {
 		tasks, err := h.service.StopIngestionTasks(req.Tasks)
 		if err != nil {
-			common.ErrorWithCode(c, 400, err.Error())
+			common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 			return
 		}
 		var result []map[string]string
@@ -1099,7 +1099,7 @@ func (h *Handler) StopIngestionTasks(c *gin.Context) {
 	} else {
 		tasks, err := h.service.StopIngestionTasksByCondition(req.Tasks, req.Email, req.Status)
 		if err != nil {
-			common.ErrorWithCode(c, 400, err.Error())
+			common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 			return
 		}
 		common.SuccessWithData(c, tasks, "Stop tasks successfully")
@@ -1123,7 +1123,7 @@ func (h *Handler) ListIngestionTasks(c *gin.Context) {
 	}
 
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 	}
 	common.SuccessWithData(c, tasks, "Get all tasks")
 }
@@ -1156,7 +1156,7 @@ type ShutdownIngestorRequest struct {
 func (h *Handler) ShutdownIngestor(c *gin.Context) {
 	var req ShutdownIngestorRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Ingestor ID is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Ingestor ID is required")
 		return
 	}
 
@@ -1218,7 +1218,7 @@ func (h *Handler) ListAllModels(c *gin.Context) {
 	// List models
 	models, err := h.service.ListAllModels(page, pageSize)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1234,18 +1234,18 @@ func (h *Handler) ShowModel(c *gin.Context) {
 
 	decodedModelName, err := common.DecodeFromBase64(encodedModelName)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if decodedModelName == "" {
-		common.ErrorWithCode(c, 400, "Decoded model name is empty")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Decoded model name is empty")
 		return
 	}
 
 	// Get model
 	model, err := h.service.GetModelByModelName(decodedModelName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -1281,7 +1281,7 @@ func (h *Handler) PingEngine(c *gin.Context) {
 	docEngine := engine.Get()
 	ctx := context.Background()
 	if err := docEngine.Ping(ctx); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
diff --git a/internal/common/error_code.go b/internal/common/error_code.go
index 568313102a..2faba7c06a 100644
--- a/internal/common/error_code.go
+++ b/internal/common/error_code.go
@@ -22,6 +22,7 @@ type ErrorCode int
 
 const (
 	CodeSuccess                ErrorCode = 0
+	CodeLackResources          ErrorCode = 1
 	CodeNotEffective           ErrorCode = 10
 	CodeExceptionError         ErrorCode = 100
 	CodeArgumentError          ErrorCode = 101
diff --git a/internal/handler/chat_session.go b/internal/handler/chat_session.go
index ca96c3e7fb..f24185753b 100644
--- a/internal/handler/chat_session.go
+++ b/internal/handler/chat_session.go
@@ -122,18 +122,18 @@ func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
 
 	var rawBody map[string]interface{}
 	if err := c.ShouldBindJSON(&rawBody); err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
 	var req ChatCompletionsRequest
 	b, err := json.Marshal(rawBody)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if err = json.Unmarshal(b, &req); err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 
diff --git a/internal/handler/document.go b/internal/handler/document.go
index a309803e9c..06c4851ddb 100644
--- a/internal/handler/document.go
+++ b/internal/handler/document.go
@@ -1476,7 +1476,7 @@ func (h *DocumentHandler) RemoveIngestionTasks(c *gin.Context) {
 	}
 
 	if req.Tasks == nil || len(req.Tasks) == 0 {
-		common.ErrorWithCode(c, 1, "task_ids is required")
+		common.ErrorWithCode(c, common.CodeLackResources, "task_ids is required")
 		return
 	}
 
diff --git a/internal/handler/models.go b/internal/handler/models.go
index cae287fafd..69a2dbb227 100644
--- a/internal/handler/models.go
+++ b/internal/handler/models.go
@@ -66,17 +66,17 @@ func (h *ModelHandler) ListAllModels(c *gin.Context) {
 func (h *ModelHandler) ShowModel(c *gin.Context) {
 	encodedModelName := c.Param("model_name")
 	if encodedModelName == "" {
-		common.ErrorWithCode(c, 400, "Encoded model name is empty")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Encoded model name is empty")
 		return
 	}
 
 	decodedModelName, err := common.DecodeFromBase64(encodedModelName)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if decodedModelName == "" {
-		common.ErrorWithCode(c, 400, "Decoded model name is empty")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Decoded model name is empty")
 		return
 	}
 
diff --git a/internal/handler/system.go b/internal/handler/system.go
index 59993eef68..14206f952a 100644
--- a/internal/handler/system.go
+++ b/internal/handler/system.go
@@ -188,7 +188,7 @@ func (h *SystemHandler) SetLogLevel(c *gin.Context) {
 func (h *SystemHandler) ListVariables(c *gin.Context) {
 	variables, err := h.systemService.ListAllVariables()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -206,22 +206,22 @@ type SetVariableHTTPRequest struct {
 func (h *SystemHandler) SetVariable(c *gin.Context) {
 	var req SetVariableHTTPRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	if req.VarName == "" {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	if req.VarValue == "" {
-		common.ErrorWithCode(c, 400, "Var value is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var value is required")
 		return
 	}
 
 	if err := h.systemService.SetVariable(req.VarName, req.VarValue); err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -233,17 +233,17 @@ func (h *SystemHandler) ShowVariable(c *gin.Context) {
 
 	varName, err := common.DecodeFromBase64(encodedVarName)
 	if err != nil {
-		common.ErrorWithCode(c, 400, err.Error())
+		common.ErrorWithCode(c, common.CodeBadRequest, err.Error())
 		return
 	}
 	if varName == "" {
-		common.ErrorWithCode(c, 400, "Var name is required")
+		common.ErrorWithCode(c, common.CodeBadRequest, "Var name is required")
 		return
 	}
 
 	variable, err := h.systemService.ShowVariable(varName)
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}
 
@@ -254,7 +254,7 @@ func (h *SystemHandler) ShowVariable(c *gin.Context) {
 func (h *SystemHandler) ListEnvironments(c *gin.Context) {
 	environments, err := h.systemService.ListEnvironments()
 	if err != nil {
-		common.ErrorWithCode(c, 500, err.Error())
+		common.ErrorWithCode(c, common.CodeServerError, err.Error())
 		return
 	}