Final 6.2.3

src/app.py

@@ -723,20 +723,27 @@ Please log in to access GAIA evaluation with Qwen models and LangGraph workflow.
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
     Fetches all questions from Unit 4 API, runs the GAIA Agent with LangGraph workflow,
-    and displays the results. Requires proper authentication for Qwen model access.
+    and displays the results. Handles OAuth authentication at runtime.
     """
     start_time = time.time()
     
     # Initialize result logger
     result_logger = GAIAResultLogger()
     
-    # Get authentication status for display
-    auth_status = format_auth_status(profile)
+    # Check OAuth environment configuration first
+    oauth_client_id = os.getenv("OAUTH_CLIENT_ID")
+    oauth_scopes = os.getenv("OAUTH_SCOPES")
+    
+    if not oauth_client_id:
+        return "❌ OAuth not configured. Please add 'hf_oauth: true' to README.md", None, format_auth_status(None), None, None, None
+    
+    if not oauth_scopes or "inference-api" not in oauth_scopes:
+        return f"❌ Missing inference-api scope. Current scopes: {oauth_scopes}. Please add 'inference-api' scope to README.md", None, format_auth_status(None), None, None, None
     
     # Get space info for code submission
     space_id = os.getenv("SPACE_ID")
 
-    # Priority order for token: 1) HF_TOKEN env var, 2) OAuth token
+    # Priority order for token: 1) HF_TOKEN env var, 2) OAuth token from profile
     hf_token = os.getenv("HF_TOKEN")
     oauth_token = None
     username = "unknown_user"
@@ -747,18 +754,29 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         username = "hf_token_user"
     elif profile:
         username = f"{profile.username}"
+        
+        # Try multiple ways to extract OAuth token
         oauth_token = getattr(profile, 'oauth_token', None) or getattr(profile, 'token', None)
-        logger.info(f"User logged in: {username}, OAuth token available: {oauth_token is not None}")
         
-        # Check if OAuth token has sufficient scopes
+        if not oauth_token:
+            for attr in ['access_token', 'id_token', 'bearer_token']:
+                token = getattr(profile, attr, None)
+                if token:
+                    oauth_token = token
+                    logger.info(f"🔑 Found OAuth token via {attr}")
+                    break
+        
         if oauth_token:
+            logger.info(f"✅ User logged in: {username}, OAuth token extracted successfully")
+            
+            # Test OAuth token validity
             try:
                 headers = {"Authorization": f"Bearer {oauth_token}"}
                 test_response = requests.get("https://huggingface.co/api/whoami", headers=headers, timeout=5)
                 
                 if test_response.status_code == 401:
                     logger.error("❌ OAuth token has insufficient scopes for Qwen model inference")
-                    return "Authentication Error: Your OAuth token lacks inference permissions. Please logout and login again with full access.", None, auth_status, None, None, None
+                    return "Authentication Error: Your OAuth token lacks inference permissions. Please logout and login again to refresh your OAuth session.", None, format_auth_status(profile), None, None, None
                 elif test_response.status_code == 200:
                     logger.info("✅ OAuth token validated successfully")
                 else:
@@ -766,13 +784,18 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                     
             except Exception as e:
                 logger.warning(f"⚠️ Could not validate OAuth token: {e}")
+        else:
+            logger.warning(f"⚠️ User {username} logged in but no OAuth token found")
+            return f"OAuth Token Missing: Could not extract authentication token for user {username}. Please logout and login again.", None, format_auth_status(profile), None, None, None
     else:
         logger.error("❌ No authentication provided")
-        return "Authentication Required: Please login with HuggingFace or set HF_TOKEN environment variable with inference permissions.", None, auth_status, None, None, None
+        return "Authentication Required: Please login with HuggingFace. Your Space has OAuth configured but you need to login first.", None, format_auth_status(None), None, None, None
 
     if not oauth_token:
-        return "Authentication Required: Valid token with inference permissions needed for Qwen model access.", None, auth_status, None, None, None
+        return "Authentication Required: Valid token with inference permissions needed for Qwen model access.", None, format_auth_status(profile), None, None, None
 
+    # Get authentication status for display
+    auth_status = format_auth_status(profile)
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
@@ -784,6 +807,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             
         if not agent.initialized:
             return "System Error: GAIA Agent failed to initialize with LangGraph workflow", None, auth_status, None, None, None
+            
+        logger.info("✅ GAIA Agent initialized successfully")
+        
     except ValueError as ve:
         logger.error(f"Authentication error: {ve}")
         return f"Authentication Error: {ve}", None, auth_status, None, None, None
@@ -818,10 +844,10 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         logger.error(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None, auth_status, None, None, None
 
-    # 3. Run GAIA Agent
+    # 3. Run GAIA Agent on questions
     results_log = []
     answers_payload = []
-    logger.info(f"Running GAIA Agent on {len(questions_data)} questions...")
+    logger.info(f"🤖 Running GAIA Agent on {len(questions_data)} questions with LangGraph workflow...")
     
     for i, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
@@ -839,6 +865,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text, 
                 "Submitted Answer": submitted_answer[:200] + "..." if len(submitted_answer) > 200 else submitted_answer
             })
+            logger.info(f"✅ Question {i} processed successfully")
         except Exception as e:
             logger.error(f"Error running GAIA agent on task {task_id}: {e}")
             error_answer = f"AGENT ERROR: {str(e)}"
@@ -853,13 +880,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         logger.error("GAIA Agent did not produce any answers to submit.")
         return "GAIA Agent did not produce any answers to submit.", pd.DataFrame(results_log), auth_status, None, None, None
 
-    # 4. Prepare Submission 
+    # 4. Prepare and submit results
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"GAIA Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    status_update = f"🚀 GAIA Agent finished processing {len(answers_payload)} questions. Submitting results for user '{username}'..."
     logger.info(status_update)
 
-    # 5. Submit
-    logger.info(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # 5. Submit to Unit 4 API
+    logger.info(f"📤 Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=120)
         response.raise_for_status()
@@ -884,17 +911,18 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         summary_file = logged_files.get("summary")
         
         final_status = (
-            f"🎉 GAIA Agent Submission Successful!\n"
-            f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"🎉 GAIA Agent Evaluation Complete!\n"
+            f"👤 User: {result_data.get('username')}\n"
+            f"🏆 Overall Score: {result_data.get('score', 'N/A')}% "
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-            f"Execution Time: {execution_time:.2f} seconds\n"
-            f"Message: {result_data.get('message', 'No message received.')}\n\n"
-            f"📁 Results saved to {len([f for f in [csv_file, json_file, summary_file] if f])} files for sharing."
+            f"⏱️ Execution Time: {execution_time:.2f} seconds\n"
+            f"💬 API Response: {result_data.get('message', 'No message received.')}\n\n"
+            f"📁 Results saved to {len([f for f in [csv_file, json_file, summary_file] if f])} files for download."
         )
-        logger.info("Submission successful.")
+        logger.info("✅ GAIA evaluation completed successfully")
         results_df = pd.DataFrame(results_log)
         return final_status, results_df, auth_status, csv_file, json_file, summary_file
+        
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
         try:
@@ -902,22 +930,22 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
         except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
+        status_message = f"❌ Submission Failed: {error_detail}"
         logger.error(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df, auth_status, None, None, None
     except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
+        status_message = "❌ Submission Failed: The request timed out."
         logger.error(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df, auth_status, None, None, None
     except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
+        status_message = f"❌ Submission Failed: Network error - {e}"
         logger.error(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df, auth_status, None, None, None
     except Exception as e:
-        status_message = f"An unexpected error occurred during submission: {e}"
+        status_message = f"❌ An unexpected error occurred during submission: {e}"
         logger.error(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df, auth_status, None, None, None
@@ -1415,87 +1443,103 @@ Please log in to access GAIA evaluation features with full inference access.
         def refresh_auth_status(request: gr.Request):
             """Refresh authentication status display with enhanced debugging"""
             try:
-                # Get OAuth profile from request with debugging
-                profile = getattr(request, 'oauth_profile', None)
+                # Use Gradio's built-in OAuth support
+                # In newer Gradio versions with HF Spaces, OAuth info should be accessible
+                profile = None
+                oauth_token = None
+                username = None
                 
-                # Try multiple ways to get user info
-                user = getattr(request, 'user', None)
-                session = getattr(request, 'session', None)
-                headers = getattr(request, 'headers', {})
+                # Try to get OAuth info from request
+                if hasattr(request, 'user') and request.user:
+                    username = getattr(request.user, 'username', None)
+                    if username:
+                        # Create a profile-like object if we have user info
+                        class GradioProfile:
+                            def __init__(self, username):
+                                self.username = username
+                                self.oauth_token = None
+                        profile = GradioProfile(username)
+                        
+                # Alternative: Check session or headers for OAuth token
+                if hasattr(request, 'session'):
+                    session = request.session
+                    oauth_token = session.get('oauth_token') or session.get('access_token')
                 
-                # Log debug information
-                logger.info(f"🔍 OAuth Debug - Profile: {profile is not None}")
-                logger.info(f"🔍 OAuth Debug - User: {user is not None}")
-                logger.info(f"🔍 OAuth Debug - Session: {session is not None}")
+                # Check request headers for authorization
+                if hasattr(request, 'headers'):
+                    auth_header = request.headers.get('authorization', '')
+                    if auth_header.startswith('Bearer '):
+                        oauth_token = auth_header[7:]
                 
-                if profile:
-                    logger.info(f"✅ Profile found: username={getattr(profile, 'username', 'unknown')}")
+                # If we found a token, add it to the profile
+                if oauth_token and profile:
+                    profile.oauth_token = oauth_token
                     
-                    # Try different ways to extract OAuth token
-                    oauth_token = None
-                    for attr in ['oauth_token', 'token', 'access_token', 'id_token']:
-                        token = getattr(profile, attr, None)
-                        if token:
-                            oauth_token = token
-                            logger.info(f"🔑 Found token via {attr}: {len(token) if token else 0} chars")
-                            break
-                    
-                    if not oauth_token and hasattr(profile, '__dict__'):
-                        logger.info(f"🔍 Profile attributes: {list(profile.__dict__.keys())}")
-                else:
-                    logger.warning("⚠️ No OAuth profile found in request")
-                
-                # Check for HF_TOKEN as fallback
-                hf_token = os.getenv("HF_TOKEN")
-                if hf_token:
-                    logger.info("✅ HF_TOKEN environment variable available")
-                else:
-                    logger.info("ℹ️ No HF_TOKEN environment variable")
+                logger.info(f"🔍 OAuth Debug - Profile: {profile is not None}, Username: {username}, Token: {oauth_token is not None}")
                 
                 return format_auth_status(profile)
                 
             except Exception as e:
                 logger.error(f"❌ Error in refresh_auth_status: {e}")
-                return f"### ❌ Authentication Error\n\nError checking auth status: {str(e)}"
+                
+                # Fallback: Check environment variables and provide helpful info
+                oauth_scopes = os.getenv("OAUTH_SCOPES")
+                oauth_client_id = os.getenv("OAUTH_CLIENT_ID")
+                
+                if oauth_client_id and oauth_scopes:
+                    return f"""
+### 🔍 OAuth Configuration Detected
+
+**🏠 Space OAuth**: ✅ Configured with scopes: {oauth_scopes}
+
+**⚠️ Authentication Detection Issue**: {str(e)}
+
+**🔧 Gradio OAuth Integration**: The Space has OAuth enabled, but we're having trouble accessing your authentication status through the Gradio interface.
+
+**💡 This is likely a Gradio version compatibility issue**. Your login should still work for the GAIA evaluation.
+
+**🎯 Try This**: Click "🚀 Run GAIA Evaluation & Submit All Answers" button - it may work even if the status display has issues.
+"""
+                else:
+                    return f"### ❌ Authentication Error\n\nError checking auth status: {str(e)}"
         
         def check_login_state(request: gr.Request):
             """Check if user is logged in and update UI accordingly with enhanced detection"""
             try:
-                profile = getattr(request, 'oauth_profile', None)
+                # Simplified approach - just try to determine if user is logged in
+                # without accessing request.user directly
                 
-                # Enhanced profile detection
-                if not profile:
-                    # Try alternative ways to get profile
-                    user = getattr(request, 'user', None)
-                    if user and hasattr(user, 'username'):
-                        # Create a minimal profile object if we have user info
-                        class MockProfile:
-                            def __init__(self, username):
-                                self.username = username
-                                self.oauth_token = None
-                        profile = MockProfile(user.username)
-                        logger.info(f"🔄 Created mock profile for user: {user.username}")
+                # Check if OAuth environment is configured
+                oauth_client_id = os.getenv("OAUTH_CLIENT_ID")
+                oauth_scopes = os.getenv("OAUTH_SCOPES")
                 
-                if profile:
-                    # User is logged in - return updated auth status
-                    auth_status = format_auth_status(profile)
-                    # Enable the run button
+                if oauth_client_id and oauth_scopes:
+                    # OAuth is configured, assume user can log in
+                    # Enable the button and let the actual authentication happen at runtime
+                    auth_status = f"""
+### 🏠 OAuth Configured Space
+
+**🔑 OAuth Status**: Space is configured with OAuth scopes: {oauth_scopes}
+
+**🎯 Ready for GAIA Evaluation**: Click the button below to start evaluation with your HuggingFace login.
+
+**💡 Note**: Authentication happens when you click "Run GAIA Evaluation" - you'll be prompted to login if needed.
+"""
                     button_update = gr.update(interactive=True, value="🚀 Run GAIA Evaluation & Submit All Answers")
-                    logger.info(f"✅ User detected as logged in: {getattr(profile, 'username', 'unknown')}")
+                    logger.info("✅ OAuth environment detected, enabling GAIA evaluation")
                     return auth_status, button_update
                 else:
-                    # User not logged in - show login required message
+                    # No OAuth configured
                     auth_status = format_auth_status(None)
-                    # Disable the run button  
-                    button_update = gr.update(interactive=False, value="🔒 Login Required for GAIA Evaluation")
-                    logger.info("ℹ️ No user login detected")
+                    button_update = gr.update(interactive=False, value="🔒 OAuth Not Configured")
+                    logger.info("ℹ️ No OAuth environment detected")
                     return auth_status, button_update
                     
             except Exception as e:
                 logger.error(f"❌ Error in check_login_state: {e}")
                 # Return safe defaults
                 auth_status = f"### ❌ Error\n\nError checking login state: {str(e)}"
-                button_update = gr.update(interactive=False, value="🔒 Login Required for GAIA Evaluation")
+                button_update = gr.update(interactive=False, value="🔒 Login Error")
                 return auth_status, button_update
         
         # Set up automatic login state checking
@@ -1540,99 +1584,81 @@ Please log in to access GAIA evaluation features with full inference access.
                     scopes_list = oauth_scopes.split()
                     debug_info.append(f"**Available Scopes**: {', '.join(scopes_list)}")
                     debug_info.append(f"**Has inference-api scope**: {'inference-api' in scopes_list}")
+                else:
+                    debug_info.append("**⚠️ No OAuth scopes configured**")
                 
-                # Check request attributes  
-                debug_info.append("\n## 🔍 Request Analysis")
-                profile = getattr(request, 'oauth_profile', None)
-                user = getattr(request, 'user', None)
-                session = getattr(request, 'session', None)
-                
-                debug_info.append(f"**Profile Object**: {profile is not None}")
-                debug_info.append(f"**User Object**: {user is not None}")
-                debug_info.append(f"**Session Object**: {session is not None}")
-                
-                # Try to access Gradio's built-in OAuth info
+                # Check README.md OAuth configuration
+                debug_info.append("\n## 📄 README.md OAuth Configuration")
                 try:
-                    # Check if Gradio has OAuth info in the request state
-                    state = getattr(request, 'state', None)
-                    if state:
-                        debug_info.append(f"**Request State**: {type(state)}")
-                        if hasattr(state, '__dict__'):
-                            state_attrs = [attr for attr in state.__dict__.keys() if 'oauth' in attr.lower() or 'user' in attr.lower() or 'auth' in attr.lower()]
-                            if state_attrs:
-                                debug_info.append(f"**State Auth Attributes**: {', '.join(state_attrs)}")
-                except Exception as state_error:
-                    debug_info.append(f"**State Check Error**: {state_error}")
-                
-                if profile:
-                    debug_info.append(f"**Profile Type**: {type(profile)}")
-                    debug_info.append(f"**Profile Username**: {getattr(profile, 'username', 'N/A')}")
-                    
-                    # Check all profile attributes
-                    if hasattr(profile, '__dict__'):
-                        attrs = list(profile.__dict__.keys())
-                        debug_info.append(f"**Profile Attributes**: {', '.join(attrs)}")
+                    with open('README.md', 'r') as f:
+                        readme_content = f.read()
+                        has_oauth = 'hf_oauth: true' in readme_content
+                        has_scopes = 'hf_oauth_scopes:' in readme_content
+                        has_inference = 'inference-api' in readme_content
                         
-                        # Check for token attributes
-                        for attr in attrs:
-                            if 'token' in attr.lower():
-                                value = getattr(profile, attr, None)
-                                debug_info.append(f"**{attr}**: {len(str(value)) if value else 0} chars")
-                    
-                    # Try to extract OAuth token using different methods
-                    oauth_token = None
-                    token_source = None
-                    for attr in ['oauth_token', 'token', 'access_token', 'id_token', 'bearer_token']:
-                        token = getattr(profile, attr, None)
-                        if token:
-                            oauth_token = token
-                            token_source = attr
-                            break
-                    
-                    if oauth_token:
-                        debug_info.append(f"**Token Found**: Via {token_source}, {len(oauth_token)} chars")
-                        
-                        # Test the token
-                        scope_info = check_oauth_scopes(oauth_token)
-                        debug_info.append(f"**Token Valid**: {scope_info.get('logged_in', False)}")
-                        debug_info.append(f"**Detected Scopes**: {', '.join(scope_info.get('scopes', []))}")
-                        debug_info.append(f"**Can Read**: {scope_info.get('can_read', False)}")
-                        debug_info.append(f"**Can Inference**: {scope_info.get('can_inference', False)}")
-                    else:
-                        debug_info.append("**Token Found**: ❌ No OAuth token found in profile")
-                
-                if user:
-                    debug_info.append(f"**User Type**: {type(user)}")
-                    if hasattr(user, '__dict__'):
-                        user_attrs = list(user.__dict__.keys())
-                        debug_info.append(f"**User Attributes**: {', '.join(user_attrs)}")
+                        debug_info.append(f"**hf_oauth: true**: {has_oauth}")
+                        debug_info.append(f"**hf_oauth_scopes defined**: {has_scopes}")
+                        debug_info.append(f"**inference-api scope**: {has_inference}")
+                except Exception as readme_error:
+                    debug_info.append(f"**README.md check error**: {readme_error}")
                 
-                # Check environment variables
+                # Environment Variables
                 debug_info.append("\n## 🔧 Environment Variables")
                 hf_token = os.getenv("HF_TOKEN")
                 debug_info.append(f"**HF_TOKEN Available**: {hf_token is not None}")
                 if hf_token:
                     debug_info.append(f"**HF_TOKEN Length**: {len(hf_token)} chars")
                 
-                # Check request headers for any auth info
-                headers = getattr(request, 'headers', {})
-                auth_headers = [h for h in headers.keys() if 'auth' in h.lower() or 'token' in h.lower()]
-                if auth_headers:
-                    debug_info.append(f"**Auth Headers**: {', '.join(auth_headers)}")
+                space_host = os.getenv("SPACE_HOST")
+                space_id = os.getenv("SPACE_ID")
+                debug_info.append(f"**SPACE_HOST**: {space_host}")
+                debug_info.append(f"**SPACE_ID**: {space_id}")
                 
                 # Gradio-specific OAuth checks
                 debug_info.append("\n## 🎨 Gradio OAuth Integration")
                 try:
-                    # Check if we're in an authenticated Gradio context
                     import gradio as gr
                     debug_info.append(f"**Gradio Version**: {gr.__version__}")
-                    
-                    # Try to access OAuth through Gradio's context
-                    # This might work differently in newer Gradio versions
+                    debug_info.append(f"**OAuth Profile Support**: Gradio should handle OAuth automatically in HF Spaces")
                     
                 except Exception as gradio_error:
                     debug_info.append(f"**Gradio OAuth Error**: {gradio_error}")
                 
+                # Authentication Test
+                debug_info.append("\n## 🧪 Authentication Test")
+                
+                if oauth_client_id and oauth_scopes:
+                    debug_info.append("**✅ OAuth Environment**: Properly configured")
+                    
+                    if "inference-api" in oauth_scopes:
+                        debug_info.append("**✅ inference-api Scope**: Available for Qwen model access")
+                        debug_info.append("**🎯 Expected Behavior**: Login should provide Qwen model access")
+                    else:
+                        debug_info.append("**❌ inference-api Scope**: Missing - Qwen models won't work")
+                        debug_info.append("**🔧 Fix**: Add 'inference-api' to hf_oauth_scopes in README.md")
+                else:
+                    debug_info.append("**❌ OAuth Environment**: Not properly configured")
+                    
+                # Success Indicators
+                debug_info.append("\n## ✅ Success Indicators")
+                
+                if oauth_client_id:
+                    debug_info.append("- ✅ OAuth is enabled for this Space")
+                else:
+                    debug_info.append("- ❌ OAuth is not enabled (missing OAUTH_CLIENT_ID)")
+                    
+                if oauth_scopes and "inference-api" in oauth_scopes:
+                    debug_info.append("- ✅ inference-api scope is configured")
+                    debug_info.append("- ✅ Should have Qwen model access when logged in")
+                else:
+                    debug_info.append("- ❌ inference-api scope is missing")
+                    debug_info.append("- ❌ Will not have Qwen model access")
+                
+                # Login status detection (avoid AuthenticationMiddleware error)
+                debug_info.append("\n## 👤 Login Status")
+                debug_info.append("**Note**: Due to Gradio OAuth integration, login status is detected at runtime")
+                debug_info.append("**Current Status**: Check by clicking 'Run GAIA Evaluation' - you'll be prompted to login if needed")
+                
                 return "\n".join(debug_info)
                 
             except Exception as e: