Update app.py

app.py

@@ -440,20 +440,28 @@ class ThinkInput(BaseModel):
 
 @tool(args_schema=ThinkInput)
 def think_through_logic(reasoning: str) -> str:
-    """Think through logic puzzles and riddles"""
-    start_time = time.time()
-    try:
-        print(f"🧠 Thinking: {reasoning[:100]}...")
-        result = f"""✅ Logic reasoning recorded.
+    """
+    Use ONLY for logic puzzles and riddles (NOT research questions).
+    
+    Use for:
+    - Brain teasers, logic puzzles, riddles
+    
+    DON'T use for:
+    - Research questions → use search_tool or wikipedia_search
+    - Math → use calculator
+    - File analysis → use file tools
+    """
+    print(f"🧠 Thinking: {reasoning[:100]}...")
+    
+    return f"""✅ Reasoning: {reasoning[:100]}
 
-Next: calculator (if math) → validate_answer → final_answer_tool
+⚠️ DO NOT CALL think_through_logic AGAIN!
 
-Remember: MUST call another tool."""
-        telemetry.record_call("think_through_logic", time.time() - start_time, True)
-        return result
-    except Exception as e:
-        telemetry.record_call("think_through_logic", time.time() - start_time, False)
-        raise
+For research → use search_tool() or wikipedia_search()
+For math → use calculator()
+If you have answer → use final_answer_tool()
+
+TAKE ACTION NOW!"""
 
 
 class PlanInput(BaseModel):
@@ -627,84 +635,126 @@ def validate_answer(proposed_answer: str, original_question: str) -> str:
 # CORE TOOLS
 # =============================================================================
 class WikipediaInput(BaseModel):
-    query: str = Field(description="Topic to search (e.g., 'Mercedes Sosa', 'Python programming')")
-
-# Replace your wikipedia_search function with:
+    query: str = Field(description="Topic to search (just the subject name)")
 
 @tool(args_schema=WikipediaInput)
-@retry_with_backoff(max_retries=2)
 def wikipedia_search(query: str) -> str:
     """
-    Search Wikipedia by scraping (API blocked on HuggingFace).
+    Search Wikipedia directly. Keep query SHORT!
+    ✅ GOOD: "Mercedes Sosa"
+    ❌ BAD: "Mercedes Sosa discography 2022 Wikipedia version"
     """
-    start_time = time.time()
+    # AGGRESSIVE query cleaning
+    original = query
+    query = query.lower().strip()
+    
+    # Remove these phrases (order matters - longest first!)
+    remove_list = [
+        "2022 english wikipedia version",
+        "english wikipedia version",
+        "2022 version",
+        "wikipedia version",
+        "latest version",
+        "wikipedia",
+        "wiki",
+        "discography",
+        "site:",
+        " the ",
+        " a ",
+        " an "
+    ]
+    
+    for phrase in remove_list:
+        query = query.replace(phrase, "")
+    
+    # Clean whitespace
+    query = " ".join(query.split()).strip()
+    
+    # Fallback if query too short
+    if len(query) < 2:
+        words = original.split()
+        query = words[0] if words else original
+    
+    print(f"📚 Wikipedia: '{original}' → '{query}'")
+    
+    # Try direct page
+    page_name = query.title().replace(" ", "_")
+    page_url = f"https://en.wikipedia.org/wiki/{page_name}"
+    
+    print(f"   Trying: {page_url}")
     
     try:
-        print(f"📚 Wikipedia search: {query}")
-        
-        # Check cache first
-        cache_key = f"wiki:{query}"
-        cached = search_cache.get(cache_key)
-        if cached:
-            print(f"   (cached)")
-            telemetry.record_call("wikipedia_search", time.time() - start_time, True)
-            return cached
-        
-        # Build direct Wikipedia URL
-        wiki_title = query.replace(' ', '_')
-        wiki_url = f"https://en.wikipedia.org/wiki/{wiki_title}"
+        headers = {'User-Agent': 'Mozilla/5.0'}
+        response = requests.get(page_url, headers=headers, timeout=10)
         
-        print(f"   Trying: {wiki_url}")
-        
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        }
-        
-        response = requests.get(wiki_url, headers=headers, timeout=10)
-        
-        # If 404, try search page
-        if response.status_code == 404:
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            title_tag = soup.find('h1', class_='firstHeading')
+            title = title_tag.get_text() if title_tag else page_name
+            
+            content_div = soup.find('div', class_='mw-parser-output')
+            preview = ""
+            if content_div:
+                paragraphs = content_div.find_all('p', limit=3)
+                for p in paragraphs:
+                    text = p.get_text().strip()
+                    if len(text) > 50:
+                        preview = text[:300]
+                        break
+            
+            result = f"""✅ Found: {title}
+URL: {page_url}
+
+Preview: {preview}...
+
+NEXT: Use scrape_and_retrieve(url="{page_url}", query="specific info")"""
+            
+            print(f"✓ Success: {title}")
+            return result
+            
+        else:
+            # Try search
+            print(f"   404, trying search")
             search_url = f"https://en.wikipedia.org/w/index.php?search={query.replace(' ', '+')}"
-            print(f"   404, trying search: {search_url}")
-            response = requests.get(search_url, headers=headers, timeout=10)
-        
-        response.raise_for_status()
-        
-        soup = BeautifulSoup(response.text, 'html.parser')
-        
-        # Get title
-        title_elem = soup.find('h1', {'id': 'firstHeading'})
-        title = title_elem.get_text() if title_elem else query
-        
-        # Get main content
-        content_div = soup.find('div', {'class': 'mw-parser-output'})
-        
-        if not content_div:
-            raise ValueError("No content found on Wikipedia page")
-        
-        # Remove unwanted elements
-        for tag in content_div(['script', 'style', 'table', 'sup', 'span.reference']):
-            tag.extract()
-        
-        content = content_div.get_text(separator='\n', strip=True)
-        
-        print(f"   Retrieved {len(content)} chars")
-        
-        # Format result
-        result = f"Wikipedia: {title}\n"
-        result += f"URL: {response.url}\n\n"
-        result += content
-        result = truncate_if_needed(result, max_length=12000)
-        
-        # Cache result
-        search_cache.put(cache_key, result)
-        
-        telemetry.record_call("wikipedia_search", time.time() - start_time, True)
-        return result
-        
+            
+            try:
+                search_resp = requests.get(search_url, headers=headers, timeout=10)
+                
+                if "wikipedia.org/wiki/" in search_resp.url and search_resp.url != search_url:
+                    return f"✅ Redirected to: {search_resp.url}\n\nUse scrape_and_retrieve() for details."
+                
+                soup = BeautifulSoup(search_resp.text, 'html.parser')
+                results = soup.find_all('div', class_='mw-search-result-heading', limit=3)
+                
+                if results:
+                    formatted = []
+                    for i, result in enumerate(results, 1):
+                        link = result.find('a')
+                        if link:
+                            title = link.get_text()
+                            href = link.get('href')
+                            full_url = f"https://en.wikipedia.org{href}"
+                            formatted.append(f"{i}. {title}\n   {full_url}")
+                    
+                    return "Wikipedia results:\n\n" + "\n\n".join(formatted) + "\n\nUse scrape_and_retrieve() with relevant URL."
+                
+                return f"""No Wikipedia page found for '{query}'.
+
+Try:
+1. search_tool("{query}")
+2. Different search term
+3. Check spelling"""
+                
+            except Exception as search_err:
+                return f"Wikipedia search failed. Try search_tool('{query}') instead."
+    
+    except requests.Timeout:
+        return f"Wikipedia timed out. Try search_tool('{query}') instead."
+    
     except Exception as e:
-        telemetry.record_call("wikipedia_search", time.time() - start_time, False)
-        raise ToolError("wikipedia_search", e, "Try using search_tool instead")
+        print(f"⚠️ Wikipedia error: {str(e)[:100]}")
+        return f"Wikipedia error. Try search_tool('{query}') instead."
 
 
 class SearchInput(BaseModel):
@@ -1502,13 +1552,9 @@ defined_tools = [
     reflect_on_progress,
     validate_answer,
     
-    # Search & Browse
-    wikipedia_search,  # NEW: Better for encyclopedic queries
+    # Core tools
     search_tool,
-    iterative_web_browser,  # NEW: Multi-turn web navigation
-    scrape_and_retrieve,
-    
-    # Core computation
+    wikipedia_search,  # ← ADD THIS NEW TOOL
     calculator,
     code_interpreter,
     
@@ -1516,12 +1562,13 @@ defined_tools = [
     read_file,
     write_file,
     list_directory,
-    analyze_data_file,  # NEW: Smart CSV/Excel analysis
     
     # Specialized
     audio_transcription_tool,
-    analyze_image,  
+    analyze_image,
     get_youtube_transcript,
+    scrape_and_retrieve,
+    analyze_chess_position,
     
     # Final
     final_answer_tool
@@ -1728,6 +1775,52 @@ OR iterative_web_browser (if needs navigation) → validate → final_answer
 **MATH CALCULATIONS**:
 → calculator → validate → final_answer
 
+═══════════════════════════════════════════════════════════════
+📚 WIKIPEDIA QUERIES - CRITICAL:
+═══════════════════════════════════════════════════════════════
+
+If question mentions Wikipedia:
+1. Use wikipedia_search() with SHORT query (just the subject)
+2. Get Wikipedia URL
+3. Use scrape_and_retrieve() for detailed info
+
+✅ CORRECT Example:
+Q: "How many albums by Mercedes Sosa 2000-2009 using Wikipedia?"
+
+Turn 1: wikipedia_search("Mercedes Sosa")
+        → Returns URL
+
+Turn 2: scrape_and_retrieve(
+          url="https://en.wikipedia.org/wiki/Mercedes_Sosa",
+          query="studio albums 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009"
+        )
+        → Returns full discography
+
+Turn 3: code_interpreter("count albums in years 2000-2009")
+        → Returns "3"
+
+Turn 4: validate_answer("3", question)
+
+Turn 5: final_answer_tool("3")
+
+❌ WRONG Examples:
+- wikipedia_search("Mercedes Sosa discography 2022 English Wikipedia version")
+- wikipedia_search("Mercedes Sosa Wikipedia")
+- wikipedia_search("How many albums Mercedes Sosa")
+
+REMEMBER: wikipedia_search() wants just the SUBJECT NAME!
+═══════════════════════════════════════════════════════════════
+
+🚨 ANTI-LOOP RULES:
+═══════════════════════════════════════════════════════════════
+
+1. NEVER call the same tool 3 times in a row
+2. think_through_logic is ONLY for logic puzzles (NOT research)
+3. Research questions need search_tool or wikipedia_search
+4. If stuck for 3 turns → try DIFFERENT tool
+
+═══════════════════════════════════════════════════════════════
+
 ═══════════════════════════════════════════════════════════════
 🎯 CRITICAL TOOL USAGE PATTERNS:
 ═══════════════════════════════════════════════════════════════
@@ -1839,14 +1932,46 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
         def agent_node(state: AgentState):
             current_turn = state.get('turn', 0) + 1
             print(f"\n{'='*70}")
-            print(f"🤖 TURN {current_turn}/{config.MAX_TURNS}")
+            print(f"🤖 AGENT TURN {current_turn}/{MAX_TURNS}")
             print('='*70)
             
-            if current_turn > config.MAX_TURNS:
+            if current_turn > MAX_TURNS:
                 return {
-                    "messages": [SystemMessage(content="Max turns reached")],
+                    "messages": [SystemMessage(content="Max turns reached.")],
                     "turn": current_turn
                 }
+            tool_history = state.get('tool_history', [])
+    
+            # Check for loops (same tool called 3+ times)
+            if len(tool_history) >= 3:
+                last_3 = tool_history[-3:]
+                
+                # If same tool 3 times in a row, FORCE change
+                if len(set(last_3)) == 1:
+                    problem_tool = last_3[0]
+                    print(f"🚨 LOOP DETECTED: {problem_tool} called 3x - FORCING CHANGE")
+                    
+                    force_msg = SystemMessage(
+                        content=f"""⚠️ EMERGENCY: You called {problem_tool}() 3 times in a row!
+        
+        THIS IS A LOOP. You MUST use a DIFFERENT tool now.
+        
+        BANNED this turn: {problem_tool}
+        
+        Pick ANY other tool and call it NOW."""
+                    )
+                    
+                    messages_to_send = state["messages"].copy()
+                    messages_to_send.append(force_msg)
+                else:
+                    messages_to_send = state["messages"].copy()
+            else:
+                messages_to_send = state["messages"].copy()
+            # ===== END LOOP DETECTION =====
+        
+            # Check if we should force reflection
+            consecutive_errors = state.get('consecutive_errors', 0)
+            should_reflect = (current_turn > 5 and current_turn % REFLECT_EVERY_N_TURNS == 0) or consecutive_errors >= 3
             
             consecutive_errors = state.get('consecutive_errors', 0)
             should_reflect = (current_turn > 5 and current_turn % config.REFLECT_EVERY_N_TURNS == 0) or consecutive_errors >= 3
@@ -1873,33 +1998,57 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
             # Invoke LLM with retries and fallback
             ai_message = None
             
-            for attempt in range(config.MAX_RETRIES):
+            for attempt in range(max_retries):
                 try:
                     ai_message = self.llm_with_tools.invoke(messages_to_send)
                     
                     if ai_message.tool_calls:
                         break
-                    
-                    print(f"⚠️ No tool calls (attempt {attempt+1})")
-                    
+                        
                 except Exception as e:
                     error_str = str(e)
-                    print(f"⚠️ {self.current_llm.upper()} error (attempt {attempt+1}): {error_str[:200]}")
+                    print(f"⚠️ Groq error (attempt {attempt+1}): {error_str[:200]}")
                     
-                    # If Groq fails and we have Claude, switch to Claude
-                    if self.current_llm == "groq" and self.claude_llm and attempt == config.MAX_RETRIES - 1:
-                        print("🔄 Switching from Groq to Claude for this question...")
-                        self.llm_with_tools = self.claude_llm
-                        self.current_llm = "claude"
-                        try:
-                            ai_message = self.llm_with_tools.invoke(messages_to_send)
-                            if ai_message.tool_calls:
-                                break
-                        except Exception as e2:
-                            print(f"⚠️ Claude also failed: {e2}")
+                    # ===== IMPROVED RATE LIMIT HANDLING =====
+                    # Check for rate limit FIRST
+                    if "429" in error_str or "rate limit" in error_str.lower():
+                        print("❌ Groq rate limit hit!")
+                        
+                        if attempt < max_retries - 1:
+                            wait = 10 * (2 ** attempt)  # 10s, 20s, 40s
+                            print(f"   Waiting {wait}s before retry...")
+                            time.sleep(wait)
+                            continue
+                        
+                        # FINAL FALLBACK: Force search_tool as safe default
+                        print("🔄 Final attempt failed - using search_tool fallback")
+                        ai_message = AIMessage(
+                            content="",
+                            tool_calls=[ToolCall(
+                                name="search_tool",
+                                args={"query": "answer to question"},
+                                id=str(uuid.uuid4())
+                            )]
+                        )
+                        break
+                    # ===== END RATE LIMIT HANDLING =====
+                    
+                    # Tool use failed error
+                    if any(kw in error_str for kw in ["tool_use_failed", "tool call validation"]):
+                        print("🚨 Tool error - forcing think_through_logic")
+                        ai_message = AIMessage(
+                            content="",
+                            tool_calls=[ToolCall(
+                                name="think_through_logic",
+                                args={"reasoning": "Processing..."},
+                                id=str(uuid.uuid4())
+                            )]
+                        )
+                        break
                     
-                    if attempt == config.MAX_RETRIES - 1:
-                        print("🚨 Forcing think_through_logic")
+                    # Final retry
+                    if attempt == max_retries - 1:
+                        print("🚨 All attempts failed - forcing think_through_logic")
                         ai_message = AIMessage(
                             content="",
                             tool_calls=[ToolCall(
@@ -1909,7 +2058,7 @@ REMEMBER: One tool per turn. No reasoning without tools. Exact answer format.
                             )]
                         )
                     else:
-                        time.sleep(config.BASE_RETRY_DELAY * (2 ** attempt))
+                        time.sleep(2 ** attempt)
             
             # Ensure tool calls exist
             if not ai_message.tool_calls: