Merge remote-tracking branch 'origin/develop' into hs/dev_0910_bugfix

# Conflicts:
#	frontend/services/mcpService.ts
#	frontend/services/uploadService.ts
#	frontend/services/userConfigService.ts
#	frontend/types/auth.ts
#	frontend/types/avatar.ts

Author: Mermaid97

.github/workflows/auto-web-check-dev.yml

@@ -0,0 +1,53 @@
+name: Run Auto Web Type Check
+
+concurrency:
+  group: auto-web-type-check-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  workflow_dispatch:
+    inputs:
+      runner_label_json:
+        description: 'runner array in json format (e.g. ["ubuntu-latest"] or ["self-hosted"])'
+        default: '["ubuntu-latest"]'
+  pull_request:
+    branches: [develop]
+    paths:
+      - 'frontend/**'
+      - '.github/workflows/**'
+  push:
+    branches: [develop]
+    paths:
+      - 'frontend/**'
+      - '.github/workflows/**'
+
+jobs:
+  type-check:
+    runs-on: ${{ fromJson(github.event.inputs.runner_label_json || '["ubuntu-latest"]') }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '18'
+
+      - name: Install dependencies
+        run: |
+          cd frontend
+          npm install
+
+      - name: Run TypeScript type check
+        run: |
+          cd frontend
+          npm run type-check
+          TYPE_CHECK_EXIT_CODE=$?
+
+          # Check if type check actually passed
+          if [ $TYPE_CHECK_EXIT_CODE -ne 0 ]; then
+            echo "❌ Type check failed with exit code $TYPE_CHECK_EXIT_CODE"
+            exit $TYPE_CHECK_EXIT_CODE
+          else
+            echo "✅ Type check passed successfully."
+          fi

backend/apps/model_managment_app.py

@@ -115,7 +115,8 @@ async def create_provider_model(request: ProviderModelRequest, authorization: Op
         model_list = await get_provider_models(model_data)
 
         # Merge existing model's max_tokens attribute
-        model_list = merge_existing_model_tokens(model_list, tenant_id, request.provider, request.model_type)
+        model_list = merge_existing_model_tokens(
+            model_list, tenant_id, request.provider, request.model_type)
 
         # Sort model list by ID
         model_list = sort_models_by_id(model_list)
@@ -164,7 +165,8 @@ async def batch_create_models(request: BatchCreateModelsRequest, authorization:
                     existing_max_tokens = existing_model_by_display["max_tokens"]
                     new_max_tokens = model["max_tokens"]
                     if existing_max_tokens != new_max_tokens:
-                        update_model_record(existing_model_by_display["model_id"], {"max_tokens": new_max_tokens}, user_id)
+                        update_model_record(existing_model_by_display["model_id"], {
+                                            "max_tokens": new_max_tokens}, user_id)
                     continue
 
             model_dict = await prepare_model_dict(
@@ -267,7 +269,7 @@ async def delete_model(display_name: str = Query(..., embed=True), authorization
     If the model is an embedding or multi_embedding type, both types will be deleted
 
     Args:
-        display_name: Display name of the model to delete (唯一键)
+        display_name: Display name of the model to delete (unique key)
         authorization: Authorization header
     """
     try:
@@ -282,10 +284,10 @@ async def delete_model(display_name: str = Query(..., embed=True), authorization
                 message=f"Model not found: {display_name}",
                 data=None
             )
-        # 支持 embedding/multi_embedding 互删
+        # Support mutual deletion of embedding/multi_embedding
         deleted_types = []
         if model["model_type"] in ["embedding", "multi_embedding"]:
-            # 查找所有 embedding/multi_embedding 且 display_name 相同的模型
+            # Find all embedding/multi_embedding models with the same display_name
             for t in ["embedding", "multi_embedding"]:
                 m = get_model_by_display_name(display_name, tenant_id)
                 if m and m["model_type"] == t:

backend/apps/user_management_app.py

@@ -24,15 +24,16 @@
 async def service_health():
     """Service health check"""
     try:
-        is_available = await check_auth_service_health()
+        await check_auth_service_health()
 
-        if is_available:
-            return JSONResponse(status_code=HTTPStatus.OK, content={"message": "Auth service is available"})
-        else:
-            return JSONResponse(status_code=HTTPStatus.SERVICE_UNAVAILABLE, content={"message": "Auth service is unavailable"})
+        return JSONResponse(status_code=HTTPStatus.OK,
+                            content={"message": "Auth service is available"})
+    except ConnectionError as e:
+        logging.error(f"Auth service health check failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail="Auth service is unavailable")
     except Exception as e:
         logging.error(f"Auth service health check failed: {str(e)}")
-        return HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Auth service is unavailable")
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail="Auth service is unavailable")
 
 
 @router.post("/signup")
@@ -50,63 +51,29 @@ async def signup(request: UserSignUpRequest):
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":success_message, "data":user_data})
     except NoInviteCodeException as e:
-        message = "Admin registration feature is not available, please contact the system administrator to configure the invite code"
-        data = {
-            "error_type": "INVITE_CODE_NOT_CONFIGURED",
-            "details": "The system has not configured the admin invite code, please contact technical support"
-        }
         logging.error(f"User registration failed by invite code: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="INVITE_CODE_NOT_CONFIGURED")
     except IncorrectInviteCodeException as e:
-        message = "Admin invite code error, please check and re-enter"
-        data = {
-            "error_type": "INVITE_CODE_INVALID",
-            "field": "inviteCode",
-            "hint": "Please confirm that the invite code is entered correctly, case-sensitive"
-        }
         logging.error(f"User registration failed by invite code: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="INVITE_CODE_INVALID")
     except UserRegistrationException as e:
-        message = "Registration service is temporarily unavailable, please try again later"
-        data = {
-            "error_type": "REGISTRATION_SERVICE_ERROR",
-            "details": "Authentication service response exception"
-        }
         logging.error(f"User registration failed by registration service: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="REGISTRATION_SERVICE_ERROR")
     except AuthApiError as e:
-        message = f"Email {request.email} has already been registered"
-        data = {
-            "error_type": "EMAIL_ALREADY_EXISTS",
-            "field": "email",
-            "suggestion": "Please use a different email address or try logging in to an existing account"
-        }
         logging.error(f"User registration failed by email already exists: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.CONFLICT,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.CONFLICT,
+                            detail="EMAIL_ALREADY_EXISTS")
     except AuthWeakPasswordError as e:
-        message = "Password strength is not enough, please set a stronger password"
-        data = {
-            "error_type": "WEAK_PASSWORD",
-            "field": "password",
-            "requirements": "Password must be at least 6 characters long, including letters, numbers, and special symbols"
-        }
         logging.error(f"User registration failed by weak password: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="WEAK_PASSWORD")
     except Exception as e:
-        message = "Registration failed, please try again later"
-        data = {
-            "error_type": "UNKNOWN_ERROR",
-            "details": f"System error: {str(e)[:100]}",
-            "suggestion": "If the problem persists, please contact technical support"
-        }
         logging.error(f"User registration failed, unknown error: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": message, "data": data})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="UNKNOWN_ERROR")
 
 
 @router.post("/signin")
@@ -119,88 +86,88 @@ async def signin(request: UserSignInRequest):
                             content=signin_content)
     except AuthApiError as e:
         logging.error(f"User login failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "Email or password error"})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="Email or password error")
     except Exception as e:
         logging.error(f"User login failed, unknown error: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Login failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Login failed")
 
 
 @router.post("/refresh_token")
 async def user_refresh_token(request: Request):
     """Refresh token"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="No authorization token provided")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
         session_data = await request.json()
         refresh_token = session_data.get("refresh_token")
         if not refresh_token:
-            return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                                content={"message": "No refresh token provided"})
+            raise ValueError("No refresh token provided")
         session_info = await refresh_user_token(authorization, refresh_token)
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":"Token refresh successful", "data":{"session": session_info}})
+    except ValueError as e:
+        logging.error(f"Refresh token failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="No refresh token provided")
     except Exception as e:
         logging.error(f"Refresh token failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Refresh token failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Refresh token failed")
 
 
 @router.post("/logout")
 async def logout(request: Request):
     """User logout"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "User not logged in"})
-
         client = get_authorized_client(authorization)
         client.auth.sign_out()
         return JSONResponse(status_code=HTTPStatus.OK,
                             content={"message":"Logout successful"})
 
     except Exception as e:
         logging.error(f"User logout failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Logout failed!"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Logout failed!")
 
 
 @router.get("/session")
 async def get_session(request: Request):
     """Get current user session"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
-
         data = await get_session_by_authorization(authorization)
         return JSONResponse(status_code=HTTPStatus.OK,
                      content={"message": "Session is valid",
                               "data": data})
     except ValueError as e:
         logging.error(f"Get user session failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "Session is invalid"})
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="Session is invalid")
     except Exception as e:
         logging.error(f"error in get user session, {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Get user session failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Get user session failed")
 
 
 @router.get("/current_user_id")
 async def get_user_id(request: Request):
     """Get current user ID, return None if not logged in"""
+    authorization = request.headers.get("Authorization")
+    if not authorization:
+        raise HTTPException(status_code=HTTPStatus.UNAUTHORIZED,
+                            detail="User not logged in")
     try:
-        authorization = request.headers.get("Authorization")
-        if not authorization:
-            return JSONResponse(status_code=HTTPStatus.UNAUTHORIZED,
-                                content={"message": "No authorization token provided"})
-
         # Use the unified token validation function
         is_valid, user = validate_token(authorization)
         if is_valid and user:
@@ -214,11 +181,13 @@ async def get_user_id(request: Request):
             return JSONResponse(status_code=HTTPStatus.OK,
                                 content={"message": "Successfully parsed user ID from token",
                                          "data": {"user_id": user_id}})
+        raise ValueError("User not logged in or session invalid")
 
-        # If all methods fail, return the session invalid information
-        return JSONResponse(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
-                            content={"message": "User not logged in or session invalid"})
+    except ValueError as e:
+        logging.error(f"Get user ID failed: {str(e)}")
+        raise HTTPException(status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+                            detail="User not logged in or session invalid")     
     except Exception as e:
         logging.error(f"Get user ID failed: {str(e)}")
-        return JSONResponse(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
-                            content={"message": "Get user ID failed"})
+        raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+                            detail="Get user ID failed")

backend/consts/model.py

@@ -25,7 +25,7 @@ def get_value(cls, status: Optional[str]) -> str:
         return status
 
 
-# 用户认证相关请求模型
+# User authentication related request models
 class UserSignUpRequest(BaseModel):
     """User registration request model"""
     email: EmailStr

backend/database/utils.py

@@ -1,17 +1,17 @@
 from typing import Any, Dict
 
 
-# 全局追踪字段管理方法
+# Global tracking field management methods
 def add_creation_tracking(data: Dict[str, Any], user_id: str) -> Dict[str, Any]:
     """
-    添加创建追踪字段（created_by和updated_by）
+    Add creation tracking fields (created_by and updated_by)
 
     Args:
-        data: 要添加字段的数据字典
-        user_id: 当前用户ID
+        data: Data dictionary to add fields to
+        user_id: Current user ID
 
     Returns:
-        Dict[str, Any]: 添加追踪字段后的数据字典
+        Dict[str, Any]: Data dictionary with tracking fields added
     """
     data_copy = data.copy()
     data_copy["created_by"] = user_id
@@ -21,14 +21,14 @@ def add_creation_tracking(data: Dict[str, Any], user_id: str) -> Dict[str, Any]:
 
 def add_update_tracking(data: Dict[str, Any], user_id: str) -> Dict[str, Any]:
     """
-    添加更新追踪字段（updated_by）
+    Add update tracking field (updated_by)
 
     Args:
-        data: 要添加字段的数据字典
-        user_id: 当前用户ID
+        data: Data dictionary to add field to
+        user_id: Current user ID
 
     Returns:
-        Dict[str, Any]: 添加追踪字段后的数据字典
+        Dict[str, Any]: Data dictionary with tracking field added
     """
     data_copy = data.copy()
     data_copy["updated_by"] = user_id