update model testing at server startup

backend/config/models_config.py

@@ -25,6 +25,10 @@ ALTERNATIVE_BENCHMARK_MODELS = [
     "meta-llama/Llama-3.1-8B-Instruct",
     "Qwen/Qwen2.5-72B-Instruct",
     "mistralai/Mistral-Small-24B-Instruct-2501",
+    # Modèles open-source qui peuvent fonctionner sans authentification
+    "HuggingFaceH4/zephyr-7b-beta",
+    "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    "microsoft/phi-2",
 ]
 
 # Required model for create_bench_config_file.py (only one default model)

backend/main.py

@@ -4,6 +4,7 @@ import os
 from dotenv import load_dotenv
 from routes import routers, session_files, active_tasks, benchmark
 from tasks.get_available_model_provider import test_models
+from datetime import datetime
 
 # Load environment variables from .env file
 load_dotenv()
@@ -11,11 +12,15 @@ load_dotenv()
 # Verify environment variables are loaded
 hf_token = os.getenv("HF_TOKEN")
 if not hf_token:
-    print("Warning: HF_TOKEN environment variable is not set. Make sure it's defined in your .env file.")
+    print("⚠️ WARNING: HF_TOKEN environment variable is not set.")
+else:
+    print("ℹ️ HF_TOKEN found in environment variables")
 
 hf_organization = os.getenv("HF_ORGANIZATION")
 if not hf_organization:
-    print("Warning: HF_ORGANIZATION environment variable is not set. Make sure it's defined in your .env file.")
+    print("⚠️ WARNING: HF_ORGANIZATION environment variable is not set.")
+else:
+    print(f"ℹ️ HF_ORGANIZATION found: {hf_organization}")
 
 app = FastAPI(title="Yourbench API")
 
@@ -31,9 +36,31 @@ app.add_middleware(
 # Ajouter un gestionnaire d'événements pour afficher les session_files au démarrage
 @app.on_event("startup")
 async def startup_event():
-    print("Application startup")
+    print("\n===== Application Startup at", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "=====\n")
     print(f"Initial session_files: {session_files}")
     
+    # Afficher des informations détaillées sur les variables d'environnement
+    print("\n===== Environment Variables Check =====")
+    hf_token = os.environ.get("HF_TOKEN")
+    if hf_token:
+        print("✅ HF_TOKEN AVAILABLE")
+    else:
+        print("❌ HF_TOKEN MISSING - HuggingFace models will not work correctly")
+    
+    hf_organization = os.environ.get("HF_ORGANIZATION")
+    if hf_organization:
+        print(f"✅ HF_ORGANIZATION: {hf_organization}")
+    else:
+        print("❌ HF_ORGANIZATION MISSING")
+    
+    print("\n===== Additional Environment Variables =====")
+    # Afficher d'autres variables utiles
+    for env_var in ["PORT", "DEBUG", "PYTHONPATH", "VIRTUAL_ENV"]:
+        value = os.environ.get(env_var)
+        if value:
+            print(f"ℹ️ {env_var}: {value}")
+    print("=======================================\n")
+    
     # Tester les modèles au démarrage et afficher les résultats
     print("===== Testing model availability at startup =====")
     test_results = test_models(verbose=True)

backend/tasks/get_available_model_provider.py

@@ -30,31 +30,104 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
     """
 
     try:
-
         load_dotenv()
         
         # Get HF token from environment
         hf_token = os.environ.get("HF_TOKEN")
         if not hf_token:
-            raise ValueError("HF_TOKEN not defined in environment")
-        # Get HF token from environment
+            if verbose:
+                logger.warning("HF_TOKEN not defined in environment, trying without token")
+            # Essayer sans token (pour certains providers qui acceptent des requêtes anonymes)
+            return _test_provider_without_token(model_name, provider, verbose)
+        
+        # Get HF organization from environment
         hf_organization = os.environ.get("HF_ORGANIZATION")
         if not hf_organization:
-            raise ValueError("HF_ORGANIZATION not defined in environment")
-        
+            if verbose:
+                logger.warning("HF_ORGANIZATION not defined in environment")
         
         if verbose:
             logger.info(f"Testing provider {provider} for model {model_name}")
         
         # Initialize the InferenceClient with the specific provider
+        try:
+            client = InferenceClient(
+                model=model_name,
+                token=hf_token,
+                provider=provider,
+                # bill_to=hf_organization if hf_organization else None,
+                timeout=3  # Increased timeout to allow model loading
+            )
+                
+            try:
+                # Use the chat completions method for testing
+                response = client.chat_completion(
+                    messages=[{"role": "user", "content": "Hello"}],
+                    max_tokens=5
+                )
+                
+                if verbose:
+                    logger.info(f"Provider {provider} is available for {model_name}")
+                return True
+                
+            except Exception as e:
+                if verbose:
+                    error_message = str(e)
+                    logger.warning(f"Error with provider {provider}: {error_message}")
+                    
+                    # Log specific error types if we can identify them
+                    if "status_code=429" in error_message:
+                        logger.warning(f"Provider {provider} rate limited. You may need to wait or upgrade your plan.")
+                    elif "status_code=401" in error_message or "status_code=403" in error_message:
+                        logger.warning(f"Authentication failed for provider {provider}. Check your token.")
+                        # Essayer sans token
+                        if verbose:
+                            logger.info(f"Trying provider {provider} without authentication")
+                        return _test_provider_without_token(model_name, provider, verbose)
+                    elif "status_code=503" in error_message:
+                        logger.warning(f"Provider {provider} service unavailable. Model may be loading or provider is down.")
+                    elif "timed out" in error_message.lower():
+                        logger.warning(f"Timeout error with provider {provider} - request timed out after 10 seconds")
+                return False
+        except Exception as auth_error:
+            if "401" in str(auth_error) or "Unauthorized" in str(auth_error):
+                # En cas d'erreur d'authentification, essayer sans token
+                if verbose:
+                    logger.warning(f"Authentication error with {provider}: {str(auth_error)}. Trying without token.")
+                return _test_provider_without_token(model_name, provider, verbose)
+            else:
+                if verbose:
+                    logger.warning(f"Error creating client for {provider}: {str(auth_error)}")
+                return False
+                
+    except Exception as e:
+        if verbose:
+            logger.warning(f"Error in test_provider: {str(e)}")
+        return False
+
+def _test_provider_without_token(model_name: str, provider: str, verbose: bool = False) -> bool:
+    """
+    Essaye de tester un provider sans token d'authentification
+    
+    Args:
+        model_name: Nom du modèle
+        provider: Provider à tester
+        verbose: Afficher les logs détaillés
+        
+    Returns:
+        True si le provider est disponible, False sinon
+    """
+    try:
+        if verbose:
+            logger.info(f"Testing provider {provider} for model {model_name} without authentication")
+        
+        # Initialize without token
         client = InferenceClient(
             model=model_name,
-            token=hf_token,
             provider=provider,
-            # bill_to=hf_organization,
-            timeout=3  # Increased timeout to allow model loading
+            timeout=3
         )
-            
+        
         try:
             # Use the chat completions method for testing
             response = client.chat_completion(
@@ -63,28 +136,17 @@ def test_provider(model_name: str, provider: str, verbose: bool = False) -> bool
             )
             
             if verbose:
-                logger.info(f"Provider {provider} is available for {model_name}")
+                logger.info(f"Provider {provider} is available for {model_name} without authentication")
             return True
             
         except Exception as e:
             if verbose:
-                error_message = str(e)
-                logger.warning(f"Error with provider {provider}: {error_message}")
-                
-                # Log specific error types if we can identify them
-                if "status_code=429" in error_message:
-                    logger.warning(f"Provider {provider} rate limited. You may need to wait or upgrade your plan.")
-                elif "status_code=401" in error_message:
-                    logger.warning(f"Authentication failed for provider {provider}. Check your token.")
-                elif "status_code=503" in error_message:
-                    logger.warning(f"Provider {provider} service unavailable. Model may be loading or provider is down.")
-                elif "timed out" in error_message.lower():
-                    logger.warning(f"Timeout error with provider {provider} - request timed out after 10 seconds")
+                logger.warning(f"Error with provider {provider} without authentication: {str(e)}")
             return False
             
     except Exception as e:
         if verbose:
-            logger.warning(f"Error in test_provider: {str(e)}")
+            logger.warning(f"Error in _test_provider_without_token: {str(e)}")
         return False
 
 def get_available_model_provider(model_name, verbose=False):
@@ -108,21 +170,48 @@ def get_available_model_provider(model_name, verbose=False):
         
         # Get providers for the model and prioritize them
         try:
-            info = model_info(model_name, token=hf_token, expand="inferenceProviderMapping")
+            # Essayer avec le token
+            try:
+                if verbose:
+                    logger.info(f"Trying to get model info for {model_name} with auth token")
+                info = model_info(model_name, token=hf_token, expand="inferenceProviderMapping")
+            except Exception as auth_error:
+                # Si l'authentification échoue, essayer sans token (pour les modèles publics)
+                if "401" in str(auth_error) or "Unauthorized" in str(auth_error):
+                    if verbose:
+                        logger.warning(f"Authentication failed for {model_name}, trying without token")
+                    # Essayer de récupérer les infos sans token
+                    try:
+                        info = model_info(model_name, expand="inferenceProviderMapping")
+                    except Exception as e:
+                        if verbose:
+                            logger.error(f"Failed to get model info without token: {str(e)}")
+                        # Comme dernier recours, retourner la liste des providers par défaut pour tester
+                        if verbose:
+                            logger.warning(f"Using default providers list as fallback for {model_name}")
+                        # Fournir une liste de providers de secours pour tester directement
+                        return _test_fallback_providers(model_name, verbose)
+                else:
+                    # Autre erreur, la relancer
+                    raise auth_error
+            
             if not hasattr(info, "inference_provider_mapping"):
                 if verbose:
                     logger.info(f"No inference providers found for {model_name}")
-                return None
+                # Essayer avec la liste de providers par défaut
+                return _test_fallback_providers(model_name, verbose)
                 
             providers = list(info.inference_provider_mapping.keys())
             if not providers:
                 if verbose:
                     logger.info(f"Empty list of providers for {model_name}")
-                return None
+                # Essayer avec la liste de providers par défaut
+                return _test_fallback_providers(model_name, verbose)
         except Exception as e:
             if verbose:
                 logger.error(f"Error retrieving model info for {model_name}: {str(e)}")
-            return None
+            # Essayer avec la liste de providers par défaut
+            return _test_fallback_providers(model_name, verbose)
             
         # Prioritize providers
         prioritized_providers = prioritize_providers(providers)
@@ -179,7 +268,39 @@ def get_available_model_provider(model_name, verbose=False):
         if verbose:
             logger.error(f"Error in get_available_model_provider: {str(e)}")
         return None
-        
+
+def _test_fallback_providers(model_name, verbose=False):
+    """
+    Fonction de secours qui teste une liste de providers communs sans passer par l'API
+    
+    Args:
+        model_name: Nom du modèle
+        verbose: Afficher les logs détaillés
+    
+    Returns:
+        Le premier provider disponible ou None
+    """
+    # Liste de providers à tester en direct
+    default_providers = ["huggingface", "sambanova", "novita", "fireworks-ai", "together", "openai", "anthropic"]
+    
+    if verbose:
+        logger.warning(f"Using fallback providers list for {model_name}: {', '.join(default_providers)}")
+    
+    # Tester chaque provider directement
+    for provider in default_providers:
+        if verbose:
+            logger.info(f"Testing fallback provider {provider} for {model_name}")
+        try:
+            if test_provider(model_name, provider, verbose):
+                if verbose:
+                    logger.info(f"FALLBACK: Provider {provider} is available for {model_name}")
+                return provider
+        except Exception as e:
+            if verbose:
+                logger.warning(f"FALLBACK: Error testing provider {provider} for {model_name}: {str(e)}")
+    
+    return None
+
 def test_models(verbose=True):
     """
     Test le modèle par défaut et les modèles alternatifs, puis retourne un résumé des résultats.
@@ -199,6 +320,20 @@ def test_models(verbose=True):
         "unavailable_models": []
     }
     
+    # Obtenez le jeton HF
+    hf_token = os.environ.get("HF_TOKEN")
+    if hf_token:
+        print("HF_TOKEN is available")
+    else:
+        print("HF_TOKEN is missing")
+
+    # Obtenez l'organisation HF
+    hf_organization = os.environ.get("HF_ORGANIZATION")
+    if hf_organization:
+        print(f"HF_ORGANIZATION is available: {hf_organization}")
+    else:
+        print("HF_ORGANIZATION is missing")
+    
     if verbose:
         print(f"Testing main default model: {DEFAULT_BENCHMARK_MODEL}")