Final 6.9.3

src/agents/router.py

@@ -173,21 +173,21 @@ class RouterAgent:
                 if question_type == QuestionType.MATHEMATICAL and pattern in [r'\bhow many\b', r'\bhow much\b']:
                     score += 2  # Boost counting questions
                 elif question_type == QuestionType.TEXT_MANIPULATION and any(special in pattern for special in ['opposite', 'reverse', 'backwards']):
-                    score += 2  # Reduced from 3 to 2 to avoid over-weighting
+                    score += 1  # Reduced further to avoid over-weighting
             if score > 0:
                 type_scores[question_type] = score
         
         # Special handling for specific question patterns
         
-        # Detect backwards/scrambled text (strong indicator)
-        if re.search(r'\.rewsna|tfel|etirw', question_lower):
+        # Detect backwards/scrambled text (strong indicator) - only for clearly backwards text
+        if re.search(r'\.rewsna\b|etirw\b|dnatsrednu\b', question_lower):
             type_scores[QuestionType.TEXT_MANIPULATION] = type_scores.get(QuestionType.TEXT_MANIPULATION, 0) + 3
             
         # Detect code execution patterns (strong indicator)
         if re.search(r'\bfinal.*output\b|\bnumeric.*output\b|\battached.*code\b', question_lower):
             type_scores[QuestionType.CODE_EXECUTION] = type_scores.get(QuestionType.CODE_EXECUTION, 0) + 4
             
-        # Detect mathematical operations with numbers
+        # Detect mathematical operations with numbers (boost mathematical score)
         if re.search(r'\b\d+.*\b(?:studio albums|between|and)\b.*\d+', question_lower):
             type_scores[QuestionType.MATHEMATICAL] = type_scores.get(QuestionType.MATHEMATICAL, 0) + 3
             
@@ -198,8 +198,20 @@ class RouterAgent:
         # Multi-step questions that need research AND calculation
         if ('how many' in question_lower or 'how much' in question_lower) and \
            any(term in question_lower for term in ['between', 'from', 'during', 'published', 'released']):
+            type_scores[QuestionType.WEB_RESEARCH] = type_scores.get(QuestionType.WEB_RESEARCH, 0) + 3  # Increased from 2
+            type_scores[QuestionType.MATHEMATICAL] = type_scores.get(QuestionType.MATHEMATICAL, 0) + 3  # Increased from 2
+            
+        # Detect factual research questions (boost web research)
+        if any(pattern in question_lower for pattern in ['who is', 'who was', 'who did', 'what is', 'when did', 'where', 'which']):
             type_scores[QuestionType.WEB_RESEARCH] = type_scores.get(QuestionType.WEB_RESEARCH, 0) + 2
-            type_scores[QuestionType.MATHEMATICAL] = type_scores.get(QuestionType.MATHEMATICAL, 0) + 2
+            
+        # Detect image/file references
+        if any(term in question_lower for term in ['image', 'picture', 'photo', 'file', 'attached', 'provided']):
+            type_scores[QuestionType.FILE_PROCESSING] = type_scores.get(QuestionType.FILE_PROCESSING, 0) + 4  # Increased from 3
+            
+        # Detect Wikipedia-specific questions
+        if any(term in question_lower for term in ['wikipedia', 'featured article', 'english wikipedia']):
+            type_scores[QuestionType.WIKIPEDIA] = type_scores.get(QuestionType.WIKIPEDIA, 0) + 4
         
         # Add detected types based on scores
         for qtype, score in type_scores.items():

src/app.py

@@ -891,9 +891,14 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     logger.info(f"📤 Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=120)
+        logger.info(f"📨 Unit 4 API response status: {response.status_code}")
+        
         response.raise_for_status()
         result_data = response.json()
         
+        # Log the actual response for debugging
+        logger.info(f"📊 Unit 4 API response data: {result_data}")
+        
         # Calculate execution time
         execution_time = time.time() - start_time
         
@@ -1536,9 +1541,14 @@ Please log in to access GAIA evaluation with Qwen models and LangGraph workflow.
             logger.info(f"📤 Submitting {len(answers_payload)} answers to: {submit_url}")
             try:
                 response = requests.post(submit_url, json=submission_data, timeout=120)
+                logger.info(f"📨 Unit 4 API response status: {response.status_code}")
+                
                 response.raise_for_status()
                 result_data = response.json()
                 
+                # Log the actual response for debugging
+                logger.info(f"📊 Unit 4 API response data: {result_data}")
+                
                 # Calculate execution time
                 execution_time = time.time() - start_time
                 

src/tools/web_search_tool.py

@@ -227,45 +227,17 @@ class WebSearchTool(BaseTool):
     
     def _search_with_duckduckgo(self, query: str, limit: int = 5, extract_content: bool = False) -> Dict[str, Any]:
         """
-        Search using DuckDuckGo - primary search engine
+        Search using DuckDuckGo - primary search engine with improved error handling
         """
         try:
             logger.info(f"🦆 DuckDuckGo search for: {query}")
             
-            # Add retry logic for DuckDuckGo rate limiting
-            max_retries = 3
-            retry_delay = 2
+            # Use DuckDuckGo text search - fail fast if there are issues
+            ddg_results = list(self.ddgs.text(query, max_results=min(limit, 10)))
             
-            for attempt in range(max_retries):
-                try:
-                    # Use DuckDuckGo text search
-                    ddg_results = list(self.ddgs.text(query, max_results=min(limit, 10)))
-                    
-                    if not ddg_results:
-                        if attempt < max_retries - 1:
-                            logger.warning(f"DuckDuckGo returned no results, retrying in {retry_delay}s...")
-                            time.sleep(retry_delay)
-                            retry_delay *= 2
-                            continue
-                        else:
-                            logger.warning("DuckDuckGo returned no results after retries")
-                            # Fall back to other search engines
-                            return self._search_with_fallback(query, limit)
-                    
-                    break
-                    
-                except Exception as e:
-                    if "rate limit" in str(e).lower() or "429" in str(e):
-                        if attempt < max_retries - 1:
-                            logger.warning(f"DuckDuckGo rate limited, retrying in {retry_delay}s...")
-                            time.sleep(retry_delay)
-                            retry_delay *= 2
-                            continue
-                        else:
-                            logger.warning("DuckDuckGo rate limited after retries, using fallback")
-                            return self._search_with_fallback(query, limit)
-                    else:
-                        raise
+            if not ddg_results:
+                logger.warning("DuckDuckGo returned no results")
+                return self._search_with_fallback(query, limit)
             
             # Process DuckDuckGo results
             results = []
@@ -299,8 +271,8 @@ class WebSearchTool(BaseTool):
             }
             
         except Exception as e:
-            logger.error(f"DuckDuckGo search error: {e}")
-            # Fall back to other search engines
+            logger.warning(f"DuckDuckGo search failed: {str(e)[:100]}")
+            # Fall back to other search engines immediately
             return self._search_with_fallback(query, limit)
     
     def _search_with_fallback(self, query: str, limit: int) -> Dict[str, Any]: