Final 6.0.3

src/app.py

@@ -220,57 +220,38 @@ class GAIAResultLogger:
         return files[:10]  # Return 10 most recent
 
 class GAIAAgentApp:
-    """Production GAIA Agent Application with Unit 4 API integration"""
+    """Production GAIA Agent Application with LangGraph workflow and Qwen models"""
     
     def __init__(self, hf_token: Optional[str] = None):
-        """Initialize the application with optional HF token"""
+        """Initialize the application with LangGraph workflow and Qwen models only"""
         
         # Priority order: 1) passed hf_token, 2) HF_TOKEN env var
         if not hf_token:
             hf_token = os.getenv("HF_TOKEN")
         
+        if not hf_token:
+            raise ValueError("HuggingFace token with inference permissions is required. Please set HF_TOKEN environment variable or login with full access.")
+        
         try:
-            # Try main QwenClient first
+            # Initialize QwenClient with token
             from models.qwen_client import QwenClient
             self.llm_client = QwenClient(hf_token=hf_token)
-            self.workflow = SimpleGAIAWorkflow(self.llm_client)
             
-            # Test if client is working with a simple generation
-            test_result = self.llm_client.generate("What is 2+2?", max_tokens=10)
-            if not test_result.success or not test_result.response.strip():
-                logger.error(f"❌ Main client test failed: {test_result}")
-                raise Exception("Main client not working - no valid response generated")
+            # Initialize LangGraph workflow with tools
+            self.workflow = SimpleGAIAWorkflow(self.llm_client)
             
             self.initialized = True
-            logger.info("✅ GAIA Agent system initialized with main client")
+            logger.info("✅ GAIA Agent system initialized with LangGraph workflow and Qwen models")
             
         except Exception as e:
-            logger.warning(f"⚠️ Main client failed ({e})")
-            
-            # Always try SimpleClient fallback when main models fail
-            logger.warning("⚠️ Attempting SimpleClient fallback...")
-            try:
-                # Fallback to simple client
-                from models.simple_client import SimpleClient
-                self.llm_client = SimpleClient(hf_token=hf_token)
-                self.workflow = SimpleGAIAWorkflow(self.llm_client)
-                
-                # Test simple client
-                test_result = self.llm_client.generate("What is 2+2?", max_tokens=10)
-                if test_result.success and test_result.response.strip():
-                    self.initialized = True
-                    logger.info("✅ GAIA Agent system initialized with SimpleClient fallback")
-                else:
-                    logger.error("❌ SimpleClient also failed to generate responses")
-                    self.initialized = False
-                    
-            except Exception as fallback_error:
-                logger.error(f"❌ SimpleClient fallback also failed: {fallback_error}")
-                self.initialized = False
+            logger.error(f"❌ Failed to initialize GAIA Agent system: {e}")
+            raise RuntimeError(f"System initialization failed: {e}. Please ensure HF_TOKEN has inference permissions.")
     
     @classmethod
     def create_with_oauth_token(cls, oauth_token: str) -> "GAIAAgentApp":
         """Create a new instance with OAuth token"""
+        if not oauth_token:
+            raise ValueError("Valid OAuth token is required for GAIA Agent initialization")
         return cls(hf_token=oauth_token)
     
     def __call__(self, question: str) -> str:
@@ -428,13 +409,14 @@ class GAIAAgentApp:
         return "\n".join(reasoning)
     
     def get_examples(self) -> list:
-        """Get example questions for the interface"""
+        """Get example questions for the interface that showcase multi-agent capabilities"""
         return [
-            "What is the capital of France?",
-            "Calculate 25% of 200",
-            "What is the square root of 144?",
-            "What is the average of 10, 15, and 20?",
             "How many studio albums were published by Mercedes Sosa between 2000 and 2009?",
+            "What is the capital of the country that has the most time zones?",
+            "Calculate the compound interest on $1000 at 5% annual rate compounded quarterly for 3 years",
+            "What is the square root of the sum of the first 10 prime numbers?",
+            "Who was the first person to walk on the moon and what year did it happen?",
+            "Compare the GDP of Japan and Germany in 2023 and tell me the difference",
         ]
 
 def check_oauth_scopes(oauth_token: str) -> Dict[str, any]:
@@ -524,32 +506,35 @@ def format_auth_status(profile: gr.OAuthProfile | None) -> str:
 **🚀 FULL SYSTEM CAPABILITIES ENABLED**
 
 **Authentication Source**: HF_TOKEN environment variable
-**Scopes**: read, inference (full access)
+**Model Access**: Qwen 2.5 models (7B/32B/72B) via HuggingFace Inference API
+**Workflow**: LangGraph multi-agent system with specialized tools
 
 **Available Features:**
 - ✅ **Advanced Model Access**: Full Qwen model capabilities (7B/32B/72B)
 - ✅ **High Performance**: 30%+ expected GAIA score
-- ✅ **Complete Pipeline**: All agents and tools fully functional
-- ✅ **Web Research**: Full DuckDuckGo search capabilities
-- ✅ **File Processing**: Complete multi-format file handling
-- ✅ **Manual Testing**: Individual question processing
+- ✅ **LangGraph Workflow**: Multi-agent orchestration with synthesis
+- ✅ **Specialized Agents**: Web research, file processing, mathematical reasoning  
+- ✅ **Professional Tools**: Wikipedia, web search, calculator, file processor
+- ✅ **Manual Testing**: Individual question processing with detailed analysis
 - ✅ **Official Evaluation**: GAIA benchmark submission
 
-💡 **Status**: Optimal configuration for GAIA benchmark performance.
+💡 **Status**: Optimal configuration for GAIA benchmark performance with real AI agents.
 """
     
     if not profile:
         return """
 ### 🔐 Authentication Status: Not Logged In
 
-Please log in to access GAIA evaluation features with full inference access.
+Please log in to access GAIA evaluation with Qwen models and LangGraph workflow.
 
-**What you can do:**
-- ✅ Manual question testing (limited functionality)
-- ❌ Official GAIA benchmark evaluation (requires login)
+**What you need:**
+- 🔑 HuggingFace login with `read` and `inference` permissions
+- 🤖 Access to Qwen 2.5 models via HF Inference API
+- 🧠 LangGraph multi-agent system capabilities
 
-**🔑 OAuth Configuration**: Login now requests both `read` and `inference` scopes for optimal performance.
-**📈 Expected Performance**: 30%+ GAIA score with full inference access.
+**🔑 OAuth Configuration**: Login requests both `read` and `inference` scopes for Qwen model access.
+**📈 Expected Performance**: 30%+ GAIA score with full LangGraph workflow and Qwen models.
+**⚠️ No Fallbacks**: System requires proper authentication - no simplified responses.
 """
     
     username = profile.username
@@ -568,7 +553,7 @@ Please log in to access GAIA evaluation features with full inference access.
     scopes = scope_info.get("scopes", [])
     status_parts.append(f"**Detected Scopes**: {', '.join(scopes) if scopes else 'None detected'}")
     status_parts.append("")
-    status_parts.append("**Available Features:**")
+    status_parts.append("**System Capabilities:**")
     
     # Safely access capabilities
     can_inference = scope_info.get("can_inference", False)
@@ -576,46 +561,50 @@ Please log in to access GAIA evaluation features with full inference access.
     
     if can_inference:
         status_parts.extend([
-            "- ✅ **Advanced Model Access**: Full Qwen model capabilities",
+            "- ✅ **Qwen Model Access**: Full Qwen 2.5 model capabilities (7B/32B/72B)",
             "- ✅ **High Performance**: 30%+ expected GAIA score",
-            "- ✅ **Complete Pipeline**: All agents and tools fully functional",
+            "- ✅ **LangGraph Workflow**: Multi-agent orchestration with synthesis",
+            "- ✅ **Specialized Agents**: Web research, file processing, reasoning",
+            "- ✅ **Professional Tools**: Wikipedia, web search, calculator, file processor",
             "- ✅ **Inference Access**: Full model generation capabilities"
         ])
     else:
         status_parts.extend([
-            "- ⚠️ **Limited Model Access**: Using fallback SimpleClient",
-            "- ⚠️ **Basic Performance**: 15%+ expected GAIA score",
-            "- ✅ **Reliable Responses**: Rule-based answers for common questions",
-            "- ❌ **No Inference Access**: Limited to read-only operations"
+            "- ❌ **No Qwen Model Access**: Insufficient OAuth permissions",
+            "- ❌ **No LangGraph Workflow**: Requires inference permissions",
+            "- ❌ **Limited Functionality**: Cannot process GAIA questions",
+            "- ❌ **No Inference Access**: Read-only permissions detected"
         ])
     
     if can_read:
         status_parts.append("- ✅ **Profile Access**: Can read user information")
     
     status_parts.extend([
-        "- ✅ **Manual Testing**: Individual question processing",
-        "- ✅ **Official Evaluation**: GAIA benchmark submission"
+        "- ✅ **Manual Testing**: Individual question processing (if authenticated)",
+        "- ✅ **Official Evaluation**: GAIA benchmark submission (if authenticated)"
     ])
     
     if not can_inference:
         status_parts.extend([
             "",
-            "🔑 **Note**: Your OAuth session may have limited scopes.",
-            "**Solution**: Try logging out and logging back in to request full inference access.",
-            "**Alternative**: Set HF_TOKEN as a Space secret for guaranteed full access."
+            "🔑 **Authentication Required**: Your OAuth session lacks inference permissions.",
+            "**Solution**: Logout and login again to request full inference access.",
+            "**Alternative**: Set HF_TOKEN as a Space secret for guaranteed Qwen model access.",
+            "**Note**: System requires Qwen model access - no simplified fallbacks available."
         ])
     else:
         status_parts.extend([
             "",
-            "🎉 **Excellent**: You have full inference access for optimal performance!"
+            "🎉 **Excellent**: You have full inference access for optimal GAIA performance!",
+            "🤖 **Ready**: LangGraph workflow with Qwen models fully operational."
         ])
     
     return "\n".join(status_parts)
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
-    Fetches all questions from Unit 4 API, runs the GAIA Agent on them, submits all answers,
-    and displays the results. Also returns updated authentication status and downloadable files.
+    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.
     """
     start_time = time.time()
     
@@ -634,7 +623,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     username = "unknown_user"
     
     if hf_token:
-        logger.info("🎯 Using HF_TOKEN environment variable for authentication")
+        logger.info("🎯 Using HF_TOKEN environment variable for Qwen model access")
         oauth_token = hf_token
         username = "hf_token_user"
     elif profile:
@@ -649,8 +638,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 test_response = requests.get("https://huggingface.co/api/whoami", headers=headers, timeout=5)
                 
                 if test_response.status_code == 401:
-                    logger.warning("⚠️ OAuth token has insufficient scopes for model inference")
-                    oauth_token = None  # Force fallback to SimpleClient
+                    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
                 elif test_response.status_code == 200:
                     logger.info("✅ OAuth token validated successfully")
                 else:
@@ -659,27 +648,33 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             except Exception as e:
                 logger.warning(f"⚠️ Could not validate OAuth token: {e}")
     else:
-        logger.info("User not logged in and no HF_TOKEN available.")
-        return "Please either login to Hugging Face or set HF_TOKEN environment variable.", None, auth_status, None, None, None
+        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
 
     if not oauth_token:
-        return "No valid authentication token available. Please login or set HF_TOKEN environment variable.", None, auth_status, None, None, None
+        return "Authentication Required: Valid token with inference permissions needed for Qwen model access.", None, auth_status, None, None, None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate GAIA Agent with token
+    # 1. Instantiate GAIA Agent with LangGraph workflow
     try:
-        logger.info("🚀 Creating GAIA Agent with authenticated token")
+        logger.info("🚀 Creating GAIA Agent with LangGraph workflow and Qwen models")
         agent = GAIAAgentApp.create_with_oauth_token(oauth_token)
             
         if not agent.initialized:
-            return "Error: GAIA Agent failed to initialize", None, auth_status, None, None, None
+            return "System Error: GAIA Agent failed to initialize with LangGraph workflow", None, auth_status, None, None, None
+    except ValueError as ve:
+        logger.error(f"Authentication error: {ve}")
+        return f"Authentication Error: {ve}", None, auth_status, None, None, None
+    except RuntimeError as re:
+        logger.error(f"System initialization error: {re}")
+        return f"System Error: {re}", None, auth_status, None, None, None
     except Exception as e:
-        logger.error(f"Error instantiating agent: {e}")
-        return f"Error initializing GAIA Agent: {e}", None, auth_status, None, None, None
-    
+        logger.error(f"Unexpected error initializing agent: {e}")
+        return f"Unexpected Error: {e}. Please check your authentication and try again.", None, auth_status, None, None, None
+
     # Agent code URL
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Local Development"
     logger.info(f"Agent code URL: {agent_code}")
@@ -811,7 +806,8 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 def create_interface():
     """Create the Gradio interface with both Unit 4 API and manual testing"""
     
-    app = GAIAAgentApp()
+    # Note: We don't initialize GAIAAgentApp here since it requires authentication
+    # Each request will create its own authenticated instance
     
     # Custom CSS for better styling
     css = """
@@ -1097,8 +1093,10 @@ def create_interface():
         
         **Advanced Multi-Agent AI System for GAIA Benchmark Questions**
         
-        This system uses specialized agents (web research, file processing, mathematical reasoning) 
-        orchestrated through LangGraph to provide accurate, well-reasoned answers to complex questions.
+        This system uses **Qwen 2.5 models (7B/32B/72B)** with specialized agents orchestrated through 
+        **LangGraph** to provide accurate, well-reasoned answers to complex questions.
+        
+        **Architecture**: Router → Specialized Agents → Tools → Synthesizer → Final Answer
         """)
         
         # Unit 4 API Section
@@ -1107,19 +1105,27 @@ def create_interface():
                 gr.Markdown("""
                 ## 🏆 GAIA Benchmark Evaluation
                 
-                **Official Unit 4 API Integration**
+                **Official Unit 4 API Integration with LangGraph Workflow**
                 
-                Run the complete GAIA Agent system on all benchmark questions and submit results to the official API.
+                Run the complete GAIA Agent system using Qwen 2.5 models and LangGraph multi-agent 
+                orchestration on all benchmark questions and submit results to the official API.
+                
+                **System Requirements:**
+                1. 🔑 **Authentication**: HuggingFace login with `read` and `inference` permissions
+                2. 🤖 **Models**: Access to Qwen 2.5 models (7B/32B/72B) via HF Inference API
+                3. 🧠 **Workflow**: LangGraph multi-agent system with specialized tools
                 
                 **Instructions:**
-                1. Log in to your Hugging Face account using the button below (**Full inference access will be requested**)
+                1. Log in to your Hugging Face account using the button below (**Full inference access required**)
                 2. Click 'Run GAIA Evaluation & Submit All Answers' to process all questions
                 3. View your official score and detailed results
                 
-                ⚠️ **Note**: This may take several minutes to process all questions.
+                ⚠️ **Note**: This may take several minutes to process all questions with the multi-agent system.
+                
+                💡 **OAuth Scopes**: Login requests both `read` and `inference` permissions 
+                for Qwen model access and optimal performance (30%+ GAIA score expected).
                 
-                💡 **OAuth Scopes**: The login will request both `read` and `inference` permissions 
-                for full model access and optimal performance (30%+ GAIA score expected).
+                🚫 **No Fallbacks**: System requires proper authentication - simplified responses not available.
                 """)
                 
                 # Authentication status section
@@ -1194,7 +1200,13 @@ Please log in to access GAIA evaluation features with full inference access.
         gr.Markdown("""
         ## 🧪 Manual Question Testing
         
-        Test individual questions with detailed analysis and reasoning.
+        Test individual questions with detailed analysis using **Qwen models** and **LangGraph workflow**.
+        
+        **Features:**
+        - 🤖 **Qwen 2.5 Models**: Intelligent tier selection (7B → 32B → 72B) based on complexity
+        - 🧠 **LangGraph Orchestration**: Multi-agent workflow with synthesis
+        - 🔧 **Specialized Agents**: Router, web research, file processing, mathematical reasoning
+        - 📊 **Detailed Analysis**: Processing details, confidence scores, cost tracking
         """)
         
         with gr.Row():
@@ -1314,31 +1326,92 @@ Please log in to access GAIA evaluation features with full inference access.
         
         # Event handlers for manual testing
         def process_and_update(question, file_input, show_reasoning):
-            answer, details, reasoning = app.process_question_detailed(question, file_input, show_reasoning)
+            """Process question with authentication check"""
+            
+            if not question.strip():
+                return "❌ Please provide a question", "", "", gr.update(visible=False)
+            
+            # Check for authentication
+            hf_token = os.getenv("HF_TOKEN")
+            
+            if not hf_token:
+                error_msg = """
+## ❌ Authentication Required
+
+**This system requires authentication to access Qwen models and LangGraph workflow.**
+
+**How to authenticate:**
+1. 🔑 **Set HF_TOKEN**: Add your HuggingFace token as an environment variable
+2. 🌐 **Use Official Evaluation**: Login via the GAIA Benchmark section above
+3. 📝 **Get Token**: Visit https://huggingface.co/settings/tokens to create one with `inference` permissions
+
+**Note**: Manual testing requires the same authentication as the official evaluation.
+"""
+                return error_msg, "", "", gr.update(visible=False)
             
-            # Format answer with markdown
-            formatted_answer = f"""
+            try:
+                # Create authenticated app instance for this request
+                app = GAIAAgentApp(hf_token=hf_token)
+                
+                # Process the question
+                answer, details, reasoning = app.process_question_detailed(question, file_input, show_reasoning)
+                
+                # Format answer with markdown
+                formatted_answer = f"""
 ## 🎯 Answer
 
 {answer}
 """
-            
-            # Format details
-            formatted_details = f"""
+                
+                # Format details
+                formatted_details = f"""
 ## 📋 Processing Details
 
 {details}
 """
-            
-            # Show/hide reasoning based on checkbox
-            reasoning_visible = show_reasoning and reasoning.strip()
-            
-            return (
-                formatted_answer,
-                formatted_details, 
-                reasoning if reasoning_visible else "",
-                gr.update(visible=reasoning_visible)
-            )
+                
+                # Show/hide reasoning based on checkbox
+                reasoning_visible = show_reasoning and reasoning.strip()
+                
+                return (
+                    formatted_answer,
+                    formatted_details, 
+                    reasoning if reasoning_visible else "",
+                    gr.update(visible=reasoning_visible)
+                )
+                
+            except ValueError as ve:
+                error_msg = f"""
+## ❌ Authentication Error
+
+{str(ve)}
+
+**Solution**: Please ensure your HF_TOKEN has `inference` permissions.
+"""
+                return error_msg, "", "", gr.update(visible=False)
+                
+            except RuntimeError as re:
+                error_msg = f"""
+## ❌ System Error
+
+{str(re)}
+
+**This may be due to:**
+- Qwen model access issues
+- HuggingFace Inference API unavailability
+- Network connectivity problems
+"""
+                return error_msg, "", "", gr.update(visible=False)
+                
+            except Exception as e:
+                error_msg = f"""
+## ❌ Unexpected Error
+
+{str(e)}
+
+**Please try again or contact support if the issue persists.**
+"""
+                return error_msg, "", "", gr.update(visible=False)
         
         submit_btn.click(
             fn=process_and_update,
@@ -1359,19 +1432,28 @@ Please log in to access GAIA evaluation features with full inference access.
         
         ### 🔧 System Architecture
         
+        **LangGraph Multi-Agent Workflow:**
         - **Router Agent**: Classifies questions and selects appropriate specialized agents
-        - **Web Research Agent**: Handles Wikipedia searches and web research
+        - **Web Research Agent**: Handles Wikipedia searches and web research with DuckDuckGo
         - **File Processing Agent**: Processes uploaded files (CSV, images, code, audio)
         - **Reasoning Agent**: Handles mathematical calculations and logical reasoning
         - **Synthesizer Agent**: Combines results from multiple agents into final answers
         
         **Models Used**: Qwen 2.5 (7B/32B/72B) with intelligent tier selection for optimal cost/performance
         
+        **Tools Available**: Wikipedia API, DuckDuckGo web search, mathematical calculator, multi-format file processor
+        
         ### 📈 Performance Metrics
-        - **Success Rate**: 100% on test scenarios
-        - **Average Response Time**: ~3 seconds per question
-        - **Cost Efficiency**: $0.01-0.40 per question depending on complexity
+        - **Success Rate**: 30%+ expected on GAIA benchmark with full authentication
+        - **Average Response Time**: ~3-5 seconds per question depending on complexity
+        - **Cost Efficiency**: $0.01-0.40 per question depending on model tier selection
         - **Architecture**: Multi-agent LangGraph orchestration with intelligent synthesis
+        - **Reliability**: Robust error handling and graceful degradation within workflow
+        
+        ### 🎯 Authentication Requirements
+        - **HF_TOKEN Environment Variable**: Best performance with full access to Qwen models
+        - **OAuth with Inference Scope**: Full access to Qwen 2.5 models via HuggingFace Inference API
+        - **No Fallback Options**: System requires proper authentication for multi-agent functionality
         """)
     
     return interface

src/models/qwen_client.py

@@ -51,49 +51,18 @@ class QwenClient:
     """HuggingFace client with fallback model support"""
     
     def __init__(self, hf_token: Optional[str] = None):
-        """Initialize the client with HuggingFace token"""
+        """Initialize the client with HuggingFace token for Qwen models only"""
         self.hf_token = hf_token or os.getenv("HUGGINGFACE_TOKEN") or os.getenv("HF_TOKEN")
         if not self.hf_token:
-            logger.warning("No HuggingFace token provided. API access may be limited.")
+            raise ValueError("HuggingFace token is required for Qwen model access. Please provide HF_TOKEN or login with inference permissions.")
         
         # Initialize cost tracking first
         self.total_cost = 0.0
         self.request_count = 0
         self.budget_limit = 0.10  # $0.10 total budget
             
-        # Define model configurations with fallbacks
+        # Define Qwen model configurations (only these models)
         self.models = {
-            ModelTier.ROUTER: ModelConfig(
-                name="google/flan-t5-small",  # Reliable and fast instruction-following model
-                tier=ModelTier.ROUTER,
-                max_tokens=512,
-                temperature=0.1,
-                cost_per_token=0.0003,
-                timeout=15,
-                requires_special_auth=False
-            ),
-            ModelTier.MAIN: ModelConfig(
-                name="google/flan-t5-base",  # Good balance of performance and speed
-                tier=ModelTier.MAIN,
-                max_tokens=1024,
-                temperature=0.1,
-                cost_per_token=0.0008,
-                timeout=25,
-                requires_special_auth=False
-            ),
-            ModelTier.COMPLEX: ModelConfig(
-                name="google/flan-t5-large",  # Best available free model
-                tier=ModelTier.COMPLEX,
-                max_tokens=2048,
-                temperature=0.1,
-                cost_per_token=0.0015,
-                timeout=35,
-                requires_special_auth=False
-            )
-        }
-        
-        # Qwen models as primary choice (will fallback if auth fails)
-        self.qwen_models = {
             ModelTier.ROUTER: ModelConfig(
                 name="Qwen/Qwen2.5-7B-Instruct",
                 tier=ModelTier.ROUTER,
@@ -129,62 +98,51 @@ class QwenClient:
         self._initialize_clients()
         
     def _initialize_clients(self):
-        """Initialize HuggingFace clients with fallback support"""
+        """Initialize HuggingFace clients for Qwen models only"""
         
-        # Try Qwen models first (preferred)
-        if self.hf_token:
-            logger.info("🎯 Attempting to initialize Qwen models...")
-            qwen_success = self._try_initialize_models(self.qwen_models, "Qwen")
-            
-            if qwen_success:
-                logger.info("✅ Qwen models initialized successfully")
-                self.models = self.qwen_models
-                return
-            else:
-                logger.warning("⚠️ Qwen models failed, falling back to standard models")
+        logger.info("🎯 Initializing Qwen models via HuggingFace Inference API...")
+        success = self._try_initialize_models(self.models, "Qwen")
         
-        # Fallback to standard HF models
-        logger.info("🔄 Initializing fallback models...")
-        fallback_success = self._try_initialize_models(self.models, "Fallback")
-        
-        if not fallback_success:
-            logger.error("❌ All model initialization failed")
+        if not success:
+            raise RuntimeError("Failed to initialize any Qwen models. Please check your HF_TOKEN has inference permissions and try again.")
         
         # Test the main model to ensure it's working
-        logger.info("🧪 Testing main model initialization...")
+        logger.info("🧪 Testing Qwen model connectivity...")
         try:
-            test_result = self.generate("Test", max_tokens=5)
+            test_result = self.generate("Hello", max_tokens=10)
             if test_result.success and test_result.response.strip():
-                logger.info(f"✅ Main model test successful: '{test_result.response.strip()}'")
+                logger.info(f"✅ Qwen models ready: '{test_result.response.strip()}'")
             else:
-                logger.error(f"❌ Main model test failed - Success: {test_result.success}, Response: '{test_result.response}', Error: {test_result.error}")
+                logger.error(f"❌ Qwen model test failed: {test_result}")
+                raise RuntimeError("Qwen models failed connectivity test")
         except Exception as e:
-            logger.error(f"❌ Main model test exception: {e}")
+            logger.error(f"❌ Qwen model test exception: {e}")
+            raise RuntimeError(f"Qwen model initialization failed: {e}")
     
     def _try_initialize_models(self, model_configs: Dict, model_type: str) -> bool:
-        """Try to initialize a set of models"""
+        """Try to initialize Qwen models"""
         success_count = 0
         
         for tier, config in model_configs.items():
             try:
-                # Test with simple generation first for Nebius models
-                if config.requires_special_auth and self.hf_token:
-                    test_client = InferenceClient(
+                # Test Qwen model authentication
+                test_client = InferenceClient(
+                    model=config.name,
+                    token=self.hf_token
+                )
+                
+                # Quick test to verify authentication and model access
+                try:
+                    test_response = test_client.chat_completion(
+                        messages=[{"role": "user", "content": "Hello"}],
                         model=config.name,
-                        token=self.hf_token
+                        max_tokens=5,
+                        temperature=0.1
                     )
-                    
-                    # Quick test to verify authentication works
-                    try:
-                        test_response = test_client.text_generation(
-                            "Hello", 
-                            max_new_tokens=5,
-                            temperature=0.1
-                        )
-                        logger.info(f"✅ {model_type} auth test passed for {config.name}")
-                    except Exception as auth_error:
-                        logger.warning(f"❌ {model_type} auth failed for {config.name}: {auth_error}")
-                        continue
+                    logger.info(f"✅ {model_type} auth test passed for {config.name}")
+                except Exception as auth_error:
+                    logger.warning(f"❌ {model_type} auth failed for {config.name}: {auth_error}")
+                    continue
                 
                 # Initialize the clients
                 self.inference_clients[tier] = InferenceClient(
@@ -303,10 +261,10 @@ class QwenClient:
                            prompt: str, 
                            tier: Optional[ModelTier] = None,
                            max_tokens: Optional[int] = None) -> InferenceResult:
-        """Async text generation with the specified model tier"""
+        """Async text generation with Qwen models via HuggingFace Inference API"""
         
         if tier is None:
-            tier = self.select_model_tier()
+            tier = self.select_model_tier(question_text=prompt)
             
         config = self.models[tier]
         client = self.inference_clients.get(tier)
@@ -319,7 +277,7 @@ class QwenClient:
                 cost_estimate=0.0,
                 response_time=0.0,
                 success=False,
-                error=f"Model {tier.value} not available"
+                error=f"Qwen model {tier.value} not available"
             )
         
         start_time = time.time()
@@ -328,100 +286,31 @@ class QwenClient:
             # Use specified max_tokens or model default
             tokens = max_tokens or config.max_tokens
             
-            # Use appropriate API based on model type
-            if config.requires_special_auth:
-                # Qwen models use chat completion API
-                messages = [{"role": "user", "content": prompt}]
-                
-                response = client.chat_completion(
-                    messages=messages,
-                    model=config.name,
-                    max_tokens=tokens,
-                    temperature=config.temperature
-                )
-                
-                # Extract response from chat completion
-                if response and response.choices:
-                    response_text = response.choices[0].message.content
-                else:
-                    raise ValueError("No response received from model")
+            # Qwen models use chat completion API
+            messages = [{"role": "user", "content": prompt}]
+            
+            logger.info(f"🤖 Generating with {config.name}...")
+            response = client.chat_completion(
+                messages=messages,
+                model=config.name,
+                max_tokens=tokens,
+                temperature=config.temperature
+            )
+            
+            # Extract response from chat completion
+            if response and response.choices:
+                response_text = response.choices[0].message.content
             else:
-                # Fallback models use text generation API
-                # Format prompt for instruction-following models like FLAN-T5
-                formatted_prompt = f"Question: {prompt}\nAnswer:"
-                
-                try:
-                    # First attempt: Standard formatted prompt
-                    logger.info(f"Attempting generation with {config.name}...")
-                    response_text = client.text_generation(
-                        formatted_prompt,
-                        max_new_tokens=tokens,
-                        temperature=config.temperature,
-                        return_full_text=False,
-                        do_sample=True if config.temperature > 0 else False
-                    )
-                    
-                    if not response_text or not response_text.strip():
-                        # Try alternative generation method if first fails
-                        logger.warning(f"Empty response from {config.name} attempt 1, trying direct prompt...")
-                        response_text = client.text_generation(
-                            prompt,
-                            max_new_tokens=min(tokens, 50),  # Smaller token limit
-                            temperature=0.7,  # Higher temperature
-                            return_full_text=False,
-                            do_sample=True
-                        )
-                    
-                    if not response_text or not response_text.strip():
-                        logger.warning(f"Empty response from {config.name} attempt 2, trying simple format...")
-                        # Try even simpler format
-                        response_text = client.text_generation(
-                            f"Answer this: {prompt}",
-                            max_new_tokens=30,
-                            temperature=0.8,
-                            return_full_text=False,
-                            do_sample=True
-                        )
-                        
-                    if not response_text or not response_text.strip():
-                        # Final attempt with minimal parameters
-                        logger.warning(f"Empty response from {config.name} attempt 3, trying minimal config...")
-                        response_text = client.text_generation(
-                            prompt[:100],  # Truncate prompt
-                            max_new_tokens=20,
-                            return_full_text=False
-                        )
-                        
-                    if not response_text or not response_text.strip():
-                        error_msg = f"No response received from {config.name} after 4 attempts. Last response: '{response_text}'"
-                        logger.error(f"❌ {error_msg}")
-                        raise ValueError(error_msg)
-                        
-                except Exception as gen_error:
-                    error_details = str(gen_error)
-                    logger.error(f"❌ Text generation failed for {config.name}: {error_details}")
-                    
-                    # Check for specific error types
-                    if "timeout" in error_details.lower():
-                        raise ValueError(f"Timeout error with {config.name}: {error_details}")
-                    elif "rate limit" in error_details.lower() or "429" in error_details:
-                        raise ValueError(f"Rate limit error with {config.name}: {error_details}")
-                    elif "auth" in error_details.lower() or "401" in error_details:
-                        raise ValueError(f"Authentication error with {config.name}: {error_details}")
-                    else:
-                        raise ValueError(f"Generation error with {config.name}: {error_details}")
-                
-                # Final validation
-                if not response_text or not response_text.strip():
-                    error_msg = f"Final validation failed for {config.name}. Response: '{response_text}'"
-                    logger.error(f"❌ {error_msg}")
-                    raise ValueError(error_msg)
+                raise ValueError(f"No response received from {config.name}")
             
             response_time = time.time() - start_time
             
             # Clean up response text
             response_text = str(response_text).strip()
             
+            if not response_text:
+                raise ValueError(f"Empty response from {config.name}")
+            
             # Estimate tokens used (rough approximation)
             estimated_tokens = len(prompt.split()) + len(response_text.split())
             cost_estimate = estimated_tokens * config.cost_per_token
@@ -430,7 +319,7 @@ class QwenClient:
             self.total_cost += cost_estimate
             self.request_count += 1
             
-            logger.info(f"✅ Generated response using {tier.value} model in {response_time:.2f}s")
+            logger.info(f"✅ Generated with {tier.value} model in {response_time:.2f}s")
             
             return InferenceResult(
                 response=response_text,
@@ -445,22 +334,7 @@ class QwenClient:
             response_time = time.time() - start_time
             error_msg = str(e)
             
-            # Check for specific authentication errors
-            if "api_key" in error_msg.lower() or "nebius" in error_msg.lower() or "unauthorized" in error_msg.lower():
-                logger.error(f"❌ Authentication failed with {tier.value} model: {error_msg}")
-                
-                # Try to reinitialize with fallback models if this was a Qwen model
-                if config.requires_special_auth:
-                    logger.info("�� Attempting to fallback to standard models due to auth failure...")
-                    self._initialize_fallback_emergency()
-                    
-                    # Retry with fallback if available
-                    fallback_client = self.inference_clients.get(tier)
-                    if fallback_client and not self.models[tier].requires_special_auth:
-                        logger.info(f"🔄 Retrying with fallback model...")
-                        return await self.generate_async(prompt, tier, max_tokens)
-            else:
-                logger.error(f"❌ Generation failed with {tier.value} model: {error_msg}")
+            logger.error(f"❌ Generation failed with {tier.value} model ({config.name}): {error_msg}")
             
             return InferenceResult(
                 response="",
@@ -472,44 +346,6 @@ class QwenClient:
                 error=error_msg
             )
     
-    def _initialize_fallback_emergency(self):
-        """Emergency fallback to standard models when auth fails"""
-        logger.warning("🚨 Emergency fallback: Switching to standard HF models")
-        
-        # Switch to fallback models
-        self.models = {
-            ModelTier.ROUTER: ModelConfig(
-                name="google/flan-t5-small",
-                tier=ModelTier.ROUTER,
-                max_tokens=512,
-                temperature=0.1,
-                cost_per_token=0.0003,
-                timeout=15,
-                requires_special_auth=False
-            ),
-            ModelTier.MAIN: ModelConfig(
-                name="google/flan-t5-base",
-                tier=ModelTier.MAIN,
-                max_tokens=1024,
-                temperature=0.1,
-                cost_per_token=0.0008,
-                timeout=25,
-                requires_special_auth=False
-            ),
-            ModelTier.COMPLEX: ModelConfig(
-                name="google/flan-t5-large",
-                tier=ModelTier.COMPLEX,
-                max_tokens=2048,
-                temperature=0.1,
-                cost_per_token=0.0015,
-                timeout=35,
-                requires_special_auth=False
-            )
-        }
-        
-        # Reinitialize with fallback models
-        self._try_initialize_models(self.models, "Emergency Fallback")
-    
     def generate(self, 
                 prompt: str, 
                 tier: Optional[ModelTier] = None,

src/models/simple_client.py

@@ -1,165 +0,0 @@
-#!/usr/bin/env python3
-"""
-Simple Model Client for GAIA Agent
-Provides reliable basic functionality when advanced models fail
-"""
-
-import logging
-import time
-from typing import Optional
-from dataclasses import dataclass
-from enum import Enum
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-class ModelTier(Enum):
-    """Model complexity tiers"""
-    ROUTER = "router"
-    MAIN = "main"
-    COMPLEX = "complex"
-
-@dataclass
-class InferenceResult:
-    """Result of model inference"""
-    response: str
-    model_used: str
-    tokens_used: int
-    cost_estimate: float
-    response_time: float
-    success: bool
-    error: Optional[str] = None
-
-class SimpleClient:
-    """Simple client that provides reliable basic functionality"""
-    
-    def __init__(self, hf_token: Optional[str] = None):
-        """Initialize simple client"""
-        self.hf_token = hf_token
-        self.total_cost = 0.0
-        self.request_count = 0
-        self.budget_limit = 0.10
-        logger.info("✅ Simple client initialized - using rule-based responses")
-    
-    def get_model_status(self) -> dict:
-        """Always return available models"""
-        return {
-            "router": True,
-            "main": True,
-            "complex": True
-        }
-    
-    def select_model_tier(self, complexity: str = "medium", budget_conscious: bool = True, question_text: str = "") -> ModelTier:
-        """Simple model selection"""
-        if "calculate" in question_text.lower() or "math" in question_text.lower():
-            return ModelTier.COMPLEX
-        elif len(question_text) > 100:
-            return ModelTier.MAIN
-        else:
-            return ModelTier.ROUTER
-    
-    def generate(self, prompt: str, tier: Optional[ModelTier] = None, max_tokens: Optional[int] = None) -> InferenceResult:
-        """Generate response using simple rules and patterns"""
-        
-        start_time = time.time()
-        
-        if tier is None:
-            tier = self.select_model_tier(question_text=prompt)
-        
-        try:
-            response = self._generate_simple_response(prompt)
-            response_time = time.time() - start_time
-            
-            # Track usage
-            estimated_tokens = len(prompt.split()) + len(response.split())
-            cost_estimate = estimated_tokens * 0.0001  # Very low cost
-            self.total_cost += cost_estimate
-            self.request_count += 1
-            
-            logger.info(f"✅ Generated simple response using {tier.value} in {response_time:.2f}s")
-            
-            return InferenceResult(
-                response=response,
-                model_used=f"simple-{tier.value}",
-                tokens_used=estimated_tokens,
-                cost_estimate=cost_estimate,
-                response_time=response_time,
-                success=True
-            )
-            
-        except Exception as e:
-            response_time = time.time() - start_time
-            logger.error(f"❌ Simple generation failed: {e}")
-            
-            return InferenceResult(
-                response="",
-                model_used=f"simple-{tier.value}",
-                tokens_used=0,
-                cost_estimate=0.0,
-                response_time=response_time,
-                success=False,
-                error=str(e)
-            )
-    
-    def _generate_simple_response(self, prompt: str) -> str:
-        """Generate response using simple rules"""
-        
-        prompt_lower = prompt.lower()
-        
-        # Mathematical questions
-        if any(word in prompt_lower for word in ["calculate", "math", "number", "sum", "average", "+", "sqrt", "square root"]):
-            if "2+2" in prompt_lower or "2 + 2" in prompt_lower or ("what is 2" in prompt_lower and "2" in prompt_lower):
-                return "The answer to 2+2 is 4. This is a basic arithmetic calculation where we add two units to two units, resulting in four units total."
-            elif "25%" in prompt_lower and "200" in prompt_lower:
-                return "25% of 200 is 50. To calculate this: 25% = 0.25, and 0.25 × 200 = 50."
-            elif "square root" in prompt_lower and "144" in prompt_lower:
-                return "The square root of 144 is 12, because 12 × 12 = 144."
-            elif "average" in prompt_lower and "10" in prompt_lower and "15" in prompt_lower and "20" in prompt_lower:
-                return "The average of 10, 15, and 20 is 15. Calculated as: (10 + 15 + 20) ÷ 3 = 45 ÷ 3 = 15."
-            else:
-                return "I can help with mathematical calculations. Please provide specific numbers and operations."
-        
-        # Geography questions
-        if "capital" in prompt_lower and "france" in prompt_lower:
-            return "The capital of France is Paris."
-        
-        # General questions
-        if "hello" in prompt_lower or "how are you" in prompt_lower:
-            return "Hello! I'm functioning well and ready to help with your questions."
-        
-        # Complex analysis questions
-        if any(word in prompt_lower for word in ["analyze", "explain", "reasoning"]):
-            return f"Based on the question '{prompt[:100]}...', I would need to analyze multiple factors and provide detailed reasoning. This requires careful consideration of the available information and logical analysis."
-        
-        # Research questions
-        if any(word in prompt_lower for word in ["who", "what", "when", "where", "research"]):
-            return f"To answer this question about '{prompt[:50]}...', I would need to research reliable sources and provide accurate information based on available data."
-        
-        # Default response
-        return f"I understand you're asking about '{prompt[:100]}...'. Let me provide a thoughtful response based on the information available and logical reasoning."
-    
-    def get_langchain_llm(self, tier: ModelTier):
-        """Return None - no LangChain integration for simple client"""
-        return None
-    
-    def get_usage_stats(self) -> dict:
-        """Get usage statistics"""
-        return {
-            "total_cost": self.total_cost,
-            "request_count": self.request_count,
-            "budget_limit": self.budget_limit,
-            "budget_remaining": self.budget_limit - self.total_cost,
-            "budget_used_percent": (self.total_cost / self.budget_limit) * 100,
-            "average_cost_per_request": self.total_cost / max(self.request_count, 1),
-            "models_available": self.get_model_status()
-        }
-    
-    def reset_usage_tracking(self):
-        """Reset usage statistics"""
-        self.total_cost = 0.0
-        self.request_count = 0
-        logger.info("Usage tracking reset")
-
-# Create alias for compatibility
-QwenClient = SimpleClient 

src/production_deployment_guide.md

@@ -1,158 +1,108 @@
 # 🚀 GAIA Agent Production Deployment Guide
 
-## Issue Resolution: OAuth Authentication
+## System Architecture: Qwen Models + LangGraph Workflow
 
-### Problem Identified ✅
+### **🎯 Updated System Requirements**
 
-The production system was failing with 0% success rate because:
+**GAIA Agent now uses ONLY:**
+- ✅ **Qwen 2.5 Models**: 7B/32B/72B via HuggingFace Inference API  
+- ✅ **LangGraph Workflow**: Multi-agent orchestration with synthesis
+- ✅ **Specialized Agents**: Router, web research, file processing, reasoning
+- ✅ **Professional Tools**: Wikipedia, web search, calculator, file processor
+- ❌ **No Fallbacks**: Requires proper authentication - no simplified responses
 
-- **Production (HF Spaces)**: Uses OAuth authentication (no HF_TOKEN environment variable)
-- **Local Development**: Uses HF_TOKEN from .env file
-- **Code Issue**: System was hardcoded to look for environment variables only
-- **Secondary Issue**: HuggingFace Inference API model compatibility problems
+### **🚨 Authentication Requirements - CRITICAL**
 
-### Solution Implemented ✅
-
-Created a **robust 3-tier fallback system** with **OAuth scope detection**:
-
-1. **OAuth Token Support**: `GAIAAgentApp.create_with_oauth_token(oauth_token)`
-2. **Automatic Fallback**: When main models fail, falls back to SimpleClient
-3. **Rule-Based Responses**: SimpleClient provides reliable answers for common questions
-4. **Always Works**: System guaranteed to provide responses in production
-5. **OAuth Scope Detection**: Real-time display of user authentication capabilities
-
-#### Technical Implementation:
+**The system now REQUIRES proper authentication:**
 
 ```python
-# 1. OAuth Token Extraction & Scope Detection
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    oauth_token = getattr(profile, 'oauth_token', None) or getattr(profile, 'token', None)
-    agent = GAIAAgentApp.create_with_oauth_token(oauth_token)
-    # Returns auth status for UI display
-    auth_status = format_auth_status(profile)
-
-# 2. OAuth Scope Detection
-def check_oauth_scopes(oauth_token: str):
-    # Tests read capability via whoami endpoint
-    can_read = requests.get("https://huggingface.co/api/whoami", headers=headers).status_code == 200
-    # Tests inference capability via model API
-    can_inference = inference_response.status_code in [200, 503]
-
-# 3. Dynamic UI Status Display
-def format_auth_status(profile):
-    # Shows detected scopes and available features
-    # Provides clear performance expectations
-    # Educational messaging about OAuth limitations
-
-# 4. Robust Fallback System
-def __init__(self, hf_token: Optional[str] = None):
-    try:
-        # Try main QwenClient with OAuth
-        self.llm_client = QwenClient(hf_token=hf_token)
-        # Test if working
-        test_result = self.llm_client.generate("Test", max_tokens=5)
-        if not test_result.success:
-            raise Exception("Main client not working")
-    except Exception:
-        # Fallback to SimpleClient
-        self.llm_client = SimpleClient(hf_token=hf_token)
-
-# 5. SimpleClient Rule-Based Responses
-class SimpleClient:
-    def _generate_simple_response(self, prompt):
-        # Mathematics: "2+2" → "4", "25% of 200" → "50"
-        # Geography: "capital of France" → "Paris"  
-        # Always provides meaningful responses
-```
-
-#### OAuth Scope Detection UI Features:
+# REQUIRED: HuggingFace token with inference permissions
+HF_TOKEN=hf_your_token_here
 
-- **Real-time Authentication Status**: Shows login state and detected scopes
-- **Capability Display**: Clear indication of available features based on scopes
-- **Performance Expectations**: 30%+ with inference scope, 15%+ with limited scopes
-- **Manual Refresh**: Users can update auth status with refresh button
-- **Educational Messaging**: Clear explanations of OAuth limitations
+# The system will FAIL without proper authentication
+# No SimpleClient fallback available
+```
 
-## 🎯 Expected Results
+### **🎯 Expected Results**
 
-After successful deployment with enhanced fallback system:
+With proper authentication and Qwen model access:
 
-### **🚀 Performance Guarantees:**
+- **✅ GAIA Benchmark Score**: 30%+ (full LangGraph workflow with Qwen models)
+- **✅ Multi-Agent Processing**: Router → Specialized Agents → Tools → Synthesis
+- **✅ Intelligent Model Selection**: 7B (fast) → 32B (balanced) → 72B (complex)
+- **✅ Professional Tools**: Wikipedia API, DuckDuckGo search, calculator, file processor
+- **✅ Detailed Analysis**: Processing details, confidence scores, cost tracking
 
-1. **With HF_TOKEN + Working Models**: 25-35% GAIA score, full capabilities
-2. **With HF_TOKEN + Failed Models**: 15-20% GAIA score, SimpleClient fallback  
-3. **OAuth Only**: 15-20% GAIA score, SimpleClient fallback
-4. **No Authentication**: Basic functionality, SimpleClient responses
+**Without proper authentication:**
+- **❌ System Initialization Fails**: No fallback options available
+- **❌ Clear Error Messages**: Guides users to proper authentication setup
 
-### **🔧 System Reliability:**
-- **100% Uptime**: Always provides responses (guaranteed SimpleClient fallback)
-- **3-Tier Fallback**: Qwen → FLAN-T5 → SimpleClient (never fails)
-- **Smart Error Recovery**: Advanced retry logic with multiple generation attempts
-- **Enhanced Debugging**: Detailed error reporting for troubleshooting
+## 🔧 Technical Implementation
 
-### **📊 Latest Production Fixes (v2.2):**
+### OAuth Authentication (Production)
 
-#### Dynamic Authentication Detection ✅
 ```python
-# Real-time login state monitoring:
-interface.load(
-    fn=check_login_state,
-    outputs=[auth_status_display, unit4_run_button],
-    every=2  # Check every 2 seconds for login state changes
-)
-
-# Button state updates based on login:
-if profile:
-    button_update = gr.update(interactive=True, value="🚀 Run GAIA Evaluation & Submit All Answers")
-else:
-    button_update = gr.update(interactive=False, value="🔒 Login Required for GAIA Evaluation")
-```
+class GAIAAgentApp:
+    def __init__(self, hf_token: Optional[str] = None):
+        if not hf_token:
+            raise ValueError("HuggingFace token with inference permissions is required")
+        
+        # Initialize QwenClient with token
+        self.llm_client = QwenClient(hf_token=hf_token)
+        
+        # Initialize LangGraph workflow with tools
+        self.workflow = SimpleGAIAWorkflow(self.llm_client)
 
-#### Model Initialization Bug Fixes ✅
-```python
-# Fixed QwenClient total_cost attribute error:
-def __init__(self, hf_token: Optional[str] = None):
-    # Initialize cost tracking FIRST
-    self.total_cost = 0.0
-    self.request_count = 0
-    self.budget_limit = 0.10
-    # Then initialize models...
+# OAuth token extraction in production
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    oauth_token = getattr(profile, 'oauth_token', None)
+    agent = GAIAAgentApp.create_with_oauth_token(oauth_token)
 ```
 
-#### Enhanced FLAN-T5 Generation ✅
-```python
-# 4-attempt generation strategy:
-1. Standard formatted prompt: "Question: {prompt}\nAnswer:"
-2. Direct prompt with higher temperature
-3. Simple format: "Answer this: {prompt}"  
-4. Minimal config with truncated prompt
-# Each with detailed error logging and specific error type detection
-```
+### Qwen Model Configuration
 
-#### OAuth Scope Request Configuration ✅
 ```python
-# OAuth now requests full inference access upfront:
-oauth_config = {
-    "scopes": ["read", "inference"],  # Request both read and inference access
+# QwenClient now uses ONLY Qwen models
+self.models = {
+    ModelTier.ROUTER: ModelConfig(
+        name="Qwen/Qwen2.5-7B-Instruct",      # Fast classification
+        cost_per_token=0.0003
+    ),
+    ModelTier.MAIN: ModelConfig(
+        name="Qwen/Qwen2.5-32B-Instruct",     # Balanced performance  
+        cost_per_token=0.0008
+    ),
+    ModelTier.COMPLEX: ModelConfig(
+        name="Qwen/Qwen2.5-72B-Instruct",     # Best performance
+        cost_per_token=0.0015
+    )
 }
+```
 
-# Environment variables for HF Spaces:
-os.environ["OAUTH_SCOPES"] = "read,inference"
+### Error Handling
+
+```python
+# Clear error messages guide users to proper authentication
+if not oauth_token:
+    return "Authentication Required: Valid token with inference permissions needed for Qwen model access."
 
-# Login button updated:
-login_button = gr.LoginButton(
-    value="🔑 Login with Full Inference Access"
-)
+try:
+    agent = GAIAAgentApp.create_with_oauth_token(oauth_token)
+except ValueError as ve:
+    return f"Authentication Error: {ve}"
+except RuntimeError as re:
+    return f"System Error: {re}"
 ```
 
 ## 🎯 Deployment Steps
 
 ### 1. Pre-Deployment Checklist
 
-- [ ] **Code Ready**: All OAuth authentication changes committed
-- [ ] **Dependencies**: `requirements.txt` updated with all packages
-- [ ] **Testing**: OAuth authentication test passes locally
+- [ ] **Code Ready**: All Qwen-only changes committed
+- [ ] **Dependencies**: `requirements.txt` updated with all packages  
+- [ ] **Testing**: QwenClient initialization test passes locally
 - [ ] **Environment**: No hardcoded tokens in code
+- [ ] **Authentication**: HF_TOKEN available with inference permissions
 
 ### 2. HuggingFace Space Configuration
 
@@ -178,11 +128,12 @@ suggested_storage: "small"
 ```
 /
 ├── src/
-│   ├── app.py                 # Main application (OAuth-enabled)
-│   │   └── qwen_client.py     # OAuth-compatible client
+│   ├── app.py                 # Main application (Qwen + LangGraph)
+│   ├── models/
+│   │   └── qwen_client.py     # Qwen-only client  
 │   ├── agents/               # All agent files
 │   ├── tools/                # All tool files
-│   ├── workflow/             # Workflow orchestration
+│   ├── workflow/             # LangGraph workflow
 │   └── requirements.txt      # All dependencies
 ├── README.md                 # Space documentation
 └── .gitignore               # Exclude sensitive files
@@ -190,12 +141,12 @@ suggested_storage: "small"
 
 ### 4. Environment Variables (Space Secrets)
 
-**🎯 CRITICAL: Set HF_TOKEN for Full Model Access**
+**🎯 CRITICAL: Set HF_TOKEN for Qwen Model Access**
 
-To get the **real GAIA Agent performance** (not SimpleClient fallback), you **MUST** set `HF_TOKEN` as a Space secret:
+To get **real GAIA Agent performance** with Qwen models and LangGraph workflow:
 
 ```bash
-# Required for full model access and GAIA performance
+# REQUIRED for Qwen model access and LangGraph functionality
 HF_TOKEN=hf_your_token_here                # REQUIRED: Your HuggingFace token
 ```
 
@@ -212,7 +163,7 @@ HF_TOKEN=hf_your_token_here                # REQUIRED: Your HuggingFace token
 - Token must have **`read`** and **`inference`** scopes
 - Generate token at: https://huggingface.co/settings/tokens
 - Select "Fine-grained" token type
-- Enable both scopes for full functionality
+- Enable both scopes for Qwen model functionality
 
 **Optional environment variables:**
 
@@ -223,39 +174,35 @@ LANGCHAIN_API_KEY=your_key_here     # Optional: LangSmith API key
 LANGCHAIN_PROJECT=gaia-agent        # Optional: LangSmith project
 ```
 
-**⚠️ DO NOT SET**: The system automatically handles OAuth in production when HF_TOKEN is available.
-
 ### 5. Authentication Flow in Production
 
 ```python
 # Production OAuth Flow:
 1. User clicks "Login with HuggingFace" button
 2. OAuth flow provides profile with token
-3. System validates OAuth token scopes
-4. If sufficient scopes: Use OAuth token for model access
-5. If limited scopes: Gracefully fallback to SimpleClient
-6. Always provides working responses regardless of token scopes
+3. System validates OAuth token for Qwen model access
+4. If sufficient scopes: Initialize QwenClient with LangGraph workflow
+5. If insufficient scopes: Show clear error message with guidance
+6. System either works fully or fails clearly - no degraded modes
 ```
 
-#### OAuth Scope Limitations ⚠️
+#### OAuth Requirements ⚠️
 
-**Common Issue**: Gradio OAuth tokens often have **limited scopes** by default:
+**CRITICAL**: Gradio OAuth tokens often have **limited scopes** by default:
 - ✅ **"read" scope**: Can access user profile, model info
-- ❌ **"inference" scope**: Cannot access model generation APIs
-- ❌ **"write" scope**: Cannot perform model inference
+- ❌ **"inference" scope**: Often missing - REQUIRED for Qwen models
+- ❌ **"write" scope**: Not needed for this application
 
 **System Behavior**:
-- **High-scope token**: Uses advanced models (Qwen, FLAN-T5) → 30%+ GAIA performance
-- **Limited-scope token**: Uses SimpleClient fallback → 15%+ GAIA performance  
-- **No token**: Uses SimpleClient fallback → 15%+ GAIA performance
+- **Full-scope token**: Uses Qwen models with LangGraph → 30%+ GAIA performance
+- **Limited-scope token**: Clear error message → User guided to proper authentication
+- **No token**: Clear error message → User guided to login
 
-**Detection & Handling**:
+**Clear Error Handling**:
 ```python
-# Automatic scope validation
-test_response = requests.get("https://huggingface.co/api/whoami", headers=headers)
+# No more fallback confusion - clear requirements
 if test_response.status_code == 401:
-    # Limited scopes detected - use fallback
-    oauth_token = None
+    return "Authentication Error: Your OAuth token lacks inference permissions. Please logout and login again with full access."
 ```
 
 ### 6. Deployment Process
@@ -273,10 +220,11 @@ if test_response.status_code == 401:
    - Ensure `app.py` is the main entry point
    - Include all dependencies in `requirements.txt`
 
-3. **Test OAuth**:
+3. **Test Authentication**:
    - Space automatically enables OAuth for Gradio apps
    - Test login/logout functionality
-   - Verify GAIA evaluation works
+   - Verify Qwen model access works
+   - Test GAIA evaluation with LangGraph workflow
 
 ### 7. Verification Steps
 
@@ -284,7 +232,10 @@ After deployment, verify these work:
 
 - [ ] **Interface Loads**: Gradio interface appears correctly
 - [ ] **OAuth Login**: Login button works and shows user profile
-- [ ] **Manual Testing**: Individual questions work with OAuth
+- [ ] **Authentication Check**: Clear error messages when insufficient permissions
+- [ ] **Qwen Model Access**: Models initialize and respond correctly
+- [ ] **LangGraph Workflow**: Multi-agent system processes questions
+- [ ] **Manual Testing**: Individual questions work with full workflow
 - [ ] **GAIA Evaluation**: Full evaluation runs and submits to Unit 4 API
 - [ ] **Results Display**: Scores and detailed results show correctly
 
@@ -292,115 +243,72 @@ After deployment, verify these work:
 
 #### Common Issues
 
-**Issue**: "GAIA Agent failed to initialize"
-**Solution**: Check OAuth token extraction in logs
+**Issue**: "HuggingFace token with inference permissions is required"
+**Solution**: Set HF_TOKEN in Space secrets or login with full OAuth permissions
 
-**Issue**: "401 Unauthorized" errors
-**Solution**: Verify OAuth token is being passed correctly
+**Issue**: "Failed to initialize any Qwen models"
+**Solution**: Verify HF_TOKEN has inference scope and Qwen model access
 
-**Issue**: "No response from models"
-**Solution**: Check HuggingFace model access permissions
+**Issue**: "Authentication Error: Your OAuth token lacks inference permissions"
+**Solution**: Logout and login again, or set HF_TOKEN as Space secret
 
 #### Debug Commands
 
 ```python
-# In Space, add debug logging to check OAuth:
+# In Space, add debug logging to check authentication:
+logger.info(f"HF_TOKEN available: {os.getenv('HF_TOKEN') is not None}")
 logger.info(f"OAuth token available: {oauth_token is not None}")
-logger.info(f"Token length: {len(oauth_token) if oauth_token else 0}")
+logger.info(f"Qwen models initialized: {client.get_model_status()}")
 ```
 
 ### 9. Performance Optimization
 
-For production efficiency:
+For production efficiency with Qwen models:
 
 ```python
-# Model Selection Strategy
-- Simple questions: 7B model (fast, cheap)
-- Medium complexity: 32B model (balanced)  
-- Complex reasoning: 72B model (best quality)
+# Intelligent Model Selection Strategy
+- Simple questions: Qwen 2.5-7B (fast, cost-effective)
+- Medium complexity: Qwen 2.5-32B (balanced performance)  
+- Complex reasoning: Qwen 2.5-72B (best quality)
 - Budget management: Auto-downgrade when budget exceeded
+- LangGraph workflow: Optimal agent routing and synthesis
 ```
 
 ### 10. Monitoring and Maintenance
 
 **Key Metrics to Monitor**:
 
-- Success rate on GAIA evaluation
+- GAIA benchmark success rate (target: 30%+)
 - Average response time per question
 - Cost per question processed
-- Error rates by question type
+- LangGraph workflow success rate
+- Qwen model availability and performance
 
 **Regular Maintenance**:
 
-- Monitor HuggingFace model availability
+- Monitor HuggingFace Inference API status
 - Update dependencies for security
-- Review and optimize agent performance
+- Review and optimize LangGraph workflow performance
 - Check Unit 4 API compatibility
+- Monitor Qwen model performance and costs
 
-## 🔧 OAuth Implementation Details
+## 🎯 Success Metrics
 
-### Token Extraction
+### Expected Production Results 🚀
 
-```python
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    oauth_token = getattr(profile, 'oauth_token', None) or getattr(profile, 'token', None)
-    agent = GAIAAgentApp.create_with_oauth_token(oauth_token)
-```
-
-### Client Creation
-
-```python
-class GAIAAgentApp:
-    def __init__(self, hf_token: Optional[str] = None):
-        try:
-            # Try main QwenClient with OAuth
-            self.llm_client = QwenClient(hf_token=hf_token)
-            # Test if working
-            test_result = self.llm_client.generate("Test", max_tokens=5)
-            if not test_result.success:
-                raise Exception("Main client not working")
-        except Exception:
-            # Fallback to SimpleClient
-            self.llm_client = SimpleClient(hf_token=hf_token)
-    
-    @classmethod
-    def create_with_oauth_token(cls, oauth_token: str):
-        return cls(hf_token=oauth_token)
-```
-
-## 📈 Success Metrics
-
-### Local Test Results ✅
-
-- **Tool Integration**: 100% success rate
-- **Agent Processing**: 100% success rate  
-- **Full Pipeline**: 100% success rate
-- **OAuth Authentication**: ✅ Working
-
-### Production Targets 🎯
+With proper deployment and authentication:
 
 - **GAIA Benchmark**: 30%+ success rate
-- **Unit 4 API**: Full integration working
-- **User Experience**: Professional OAuth-enabled interface
-- **System Reliability**: <1% error rate
-
-## 🚀 Ready for Deployment
-
-**✅ OAUTH AUTHENTICATION ISSUE COMPLETELY RESOLVED**
-
-The system now has **guaranteed reliability** in production:
-
-- **OAuth Integration**: ✅ Working with HuggingFace authentication
-- **Fallback System**: ✅ 3-tier redundancy ensures always-working responses  
-- **Production Ready**: ✅ No more 0% success rates or authentication failures
-- **User Experience**: ✅ Professional interface with reliable functionality
+- **LangGraph Workflow**: Multi-agent orchestration working
+- **Qwen Model Performance**: Intelligent tier selection (7B→32B→72B)
+- **User Experience**: Professional interface with clear authentication
+- **System Reliability**: Clear success/failure modes (no degraded performance)
 
 ### Final Status:
-- **Problem**: 0% GAIA success rate due to OAuth authentication mismatch
-- **Solution**: Robust 3-tier fallback system with OAuth support
-- **Result**: Guaranteed working system with 15%+ minimum GAIA success rate
+- **Architecture**: Qwen 2.5 models + LangGraph multi-agent workflow
+- **Requirements**: Clear authentication requirements (HF_TOKEN or OAuth with inference)
+- **Performance**: 30%+ GAIA benchmark with full functionality
+- **Reliability**: Robust error handling with clear user guidance
 - **Deployment**: Ready for immediate HuggingFace Space deployment
 
-**The authentication barrier has been eliminated. The GAIA Agent is now production-ready!** 🎉
-
-The system is now OAuth-compatible and ready for production deployment to HuggingFace Spaces. The authentication issue has been resolved, and the system is guaranteed to provide working responses in all scenarios.
+**The GAIA Agent is now a focused, high-performance system using proper AI models and multi-agent orchestration!** 🎉