Update app.py

app.py

@@ -63,6 +63,7 @@ def retry_api_request(max_retries=3, wait_time=10):
     return decorator
 
 # --- Single model request function for Hugging Face ---
+
 @retry_api_request()
 def make_hf_request(model_name, messages, temperature, max_tokens, token=None):
     """
@@ -804,6 +805,51 @@ def run_benchmark(hf_models, topics, difficulties, t, model_config, token=None):
     print(f"Unresponsive models during this run: {unresponsive_models}")
     return results, cumulative_avg_rank, s_t
 
+def check_model_availability(models, token):
+    """Test if models are available with the provided token"""
+    availability_results = {}
+    
+    for model_name in models:
+        st.write(f"Testing availability of {model_name}...")
+        try:
+            # Create a simple test prompt
+            test_prompt = "Hello, are you available?"
+            
+            # Use a short timeout to quickly test connectivity
+            client = InferenceClient(model=model_name, token=token)
+            response = client.text_generation(
+                test_prompt,
+                max_new_tokens=10,
+                temperature=0.7,
+                do_sample=True
+            )
+            
+            availability_results[model_name] = {
+                "available": True,
+                "response": response[:50] + "..." if len(response) > 50 else response
+            }
+            st.success(f"✅ {model_name} is available")
+            
+        except Exception as e:
+            error_msg = str(e)
+            availability_results[model_name] = {
+                "available": False,
+                "error": error_msg
+            }
+            
+            if "401" in error_msg or "unauthorized" in error_msg.lower():
+                st.error(f"❌ {model_name}: Authentication error. Check your API token.")
+            elif "404" in error_msg or "not found" in error_msg.lower():
+                st.error(f"❌ {model_name}: Model not found. It may not exist or you may not have access.")
+            elif "429" in error_msg or "rate limit" in error_msg.lower():
+                st.error(f"❌ {model_name}: Rate limit exceeded. Try again later.")
+            else:
+                st.error(f"❌ {model_name}: Unknown error: {error_msg}")
+                
+        time.sleep(1)  # Add delay between checks
+    
+    return availability_results
+
 # Streamlit UI
 st.title("LLM Benchmark")
 
@@ -848,6 +894,35 @@ model_config = {}
 for model in selected_models:
     model_config[model] = {"name": model, "role": "both"}
 
+if st.sidebar.button("Test Selected Models"):
+    if not hf_token:
+        st.error("Please enter your Hugging Face API token")
+    elif not selected_models:
+        st.error("Please select at least one model")
+    else:
+        with st.spinner("Testing model availability..."):
+            availability = check_model_availability(selected_models, hf_token)
+            
+            # Show results in a table
+            availability_df = pd.DataFrame([
+                {
+                    "Model": model,
+                    "Available": info["available"],
+                    "Status": "Available" if info["available"] else "Error",
+                    "Details": info.get("response", "") if info["available"] else info.get("error", "")
+                }
+                for model, info in availability.items()
+            ])
+            
+            st.dataframe(availability_df)
+            
+            # Check if we have enough models to run the benchmark
+            available_models = [m for m, info in availability.items() if info["available"]]
+            if len(available_models) >= 2:
+                st.success(f"{len(available_models)} models are available for benchmarking")
+            else:
+                st.error("You need at least 2 available models to run the benchmark")
+
 # Start benchmark button
 if st.sidebar.button("Start Benchmark"):
     if not hf_token: