Update app.py

app.py

@@ -7,6 +7,7 @@ import asyncio
 import aiohttp
 import time
 import random
+import json
 from smolagents import FinalAnswerTool, Tool, tool, OpenAIServerModel, DuckDuckGoSearchTool, CodeAgent, VisitWebpageTool
 
 
@@ -20,6 +21,35 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 OPENAI_TOKEN = os.getenv("OPENAI_API_KEY")
 
+# --- Custom Tools ---
+class ReliableSearchTool(Tool):
+    """A search tool that handles timeouts and rate limits gracefully."""
+    
+    def __init__(self):
+        super().__init__(
+            name="reliable_search",
+            description="Search the web for information with built-in retry and fallback mechanisms",
+            fn=self.search
+        )
+        self.ddg_tool = DuckDuckGoSearchTool()
+        self.max_retries = 3
+        self.timeout = 10
+        
+    def search(self, query: str) -> str:
+        """Search the web with retry logic and fallbacks."""
+        for attempt in range(self.max_retries):
+            try:
+                # Try DuckDuckGo first
+                result = self.ddg_tool(query)
+                if result and len(result) > 50:  # Ensure we got a meaningful result
+                    return result
+            except Exception as e:
+                print(f"DuckDuckGo search failed (attempt {attempt+1}/{self.max_retries}): {e}")
+                time.sleep(2)  # Brief pause before retry
+        
+        # If all DuckDuckGo attempts failed, return a fallback response
+        return f"I couldn't search for '{query}' due to search service limitations. Using my existing knowledge instead."
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class SlpMultiAgent:
@@ -35,20 +65,19 @@ class SlpMultiAgent:
         MAX_QUESTION_LENGTH = 1000
         short_question = question  # [:MAX_QUESTION_LENGTH]
         
-        # Use GPT-3.5-turbo model with higher rate limits
+        # Use GPT-3.5-turbo model with optimized settings
         model = OpenAIServerModel(
-            model_id="gpt-3.5-turbo-16k", 
-            temperature=0.0, 
-            max_tokens=1000
-            # Removed request_timeout parameter
+            model_id="gpt-3.5-turbo", 
+            temperature=0.1,  # Slight randomness for better reasoning
+            max_tokens=800    # Reduced tokens for cost efficiency
         )
         
         # Here you can implement your agent logic, tools, and model calls
         web_agent = CodeAgent(
-            tools=[DuckDuckGoSearchTool(), VisitWebpageTool()],
+            tools=[ReliableSearchTool(), VisitWebpageTool()],  # Use our custom reliable search tool
             model=model,
-            additional_authorized_imports=["pandas", "time"],
-            max_steps=5,  # Reduced steps to avoid hitting rate limits
+            additional_authorized_imports=["pandas", "time", "json", "requests"],
+            max_steps=3,  # Further reduced steps for efficiency
             name="WebAgent",
             verbosity_level=0,
             description="An agent that can search the web and visit webpages to find information."
@@ -56,10 +85,9 @@ class SlpMultiAgent:
 
         manager_agent = CodeAgent(
             model=OpenAIServerModel(
-                model_id="gpt-3.5-turbo-16k",
-                temperature=0.0,
-                max_tokens=1000
-                # Removed request_timeout parameter
+                model_id="gpt-3.5-turbo",
+                temperature=0.1, 
+                max_tokens=800
             ),
             tools=[],
             managed_agents=[web_agent],
@@ -67,11 +95,13 @@ class SlpMultiAgent:
             description="A manager agent that can delegate tasks to other agents and manage their execution.",
             additional_authorized_imports=[
                 "pandas",
-                "time"
+                "time",
+                "json",
+                "requests"
             ],
             planning_interval=3,
             verbosity_level=1,
-            max_steps=10,
+            max_steps=6,  # Reduced steps for efficiency
             final_answer_checks=[check_reasoning]
         )
         
@@ -85,18 +115,15 @@ class SlpMultiAgent:
                 result = await loop.run_in_executor(
                     None,
                     lambda: manager_agent.run(f"""
-                    You are a question answering agent that specializes in complex questions requiring multiple steps.
+                    Answer this question accurately and concisely:
                     
-                    Guidelines:
-                    1. Think step by step before answering
-                    2. Use tools only when necessary
-                    3. Use your own knowledge when possible
-                    4. Be clear about uncertainties
-                    5. Provide complete answers
-                    6. When using code, keep it minimal and focused
-                    7. For code blocks, use <code> and </code> tags, NOT triple backticks
+                    {short_question}
                     
-                    Here is the question: {short_question}
+                    Instructions:
+                    - Think step by step
+                    - Use search only if you need current/specific information
+                    - Be precise and factual
+                    - If uncertain, state your confidence level
                     """)
                 )
                 break  # Success, exit retry loop
@@ -125,12 +152,11 @@ def check_reasoning(final_answer, agent_memory):
     try:
         multimodal_model = OpenAIServerModel(
             model_id="gpt-3.5-turbo", 
-            max_tokens=500
-            # Removed request_timeout parameter
+            max_tokens=100  # Reduced tokens for cost efficiency
         )
         
-        # Simplified prompt to reduce token usage
-        prompt = f"Is this answer correct and well-reasoned? Answer: {final_answer}"
+        # More focused validation prompt
+        prompt = f"Rate answer quality 1-10: {final_answer[:200]}..."
         
         messages = [
             {
@@ -140,17 +166,24 @@ def check_reasoning(final_answer, agent_memory):
         ]
         
         # Add retry mechanism for rate limits
-        max_retries = 3
+        max_retries = 2  # Reduced retries
         for attempt in range(max_retries):
             try:
                 output = multimodal_model(messages)
                 if hasattr(output, 'content'):
-                    return True  # Simplified to always pass to avoid errors
+                    # Actually check the response instead of always returning True
+                    response = output.content.lower()
+                    # Look for quality indicators
+                    if any(word in response for word in ['7', '8', '9', '10', 'good', 'correct']):
+                        return True
+                    elif any(word in response for word in ['1', '2', '3', '4', 'poor', 'wrong']):
+                        return False
+                    return True  # Default to pass if unclear
                 break
             except Exception as e:
                 if attempt < max_retries - 1:
                     print(f"Retry {attempt+1}/{max_retries} due to: {e}")
-                    time.sleep(5)  # Wait before retrying
+                    time.sleep(3)  # Reduced wait time
                 else:
                     print(f"Final attempt failed: {e}")
         
@@ -221,8 +254,8 @@ async def run_and_submit_all(profile):
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
     
-    # Process questions with lower concurrency to avoid rate limits
-    semaphore = asyncio.Semaphore(1)  # Process one question at a time
+    # Process questions with optimized concurrency
+    semaphore = asyncio.Semaphore(2)  # Process 2 questions at a time for better efficiency
     
     async def process_question(item):
         task_id = item.get("task_id")
@@ -242,12 +275,12 @@ async def run_and_submit_all(profile):
                 except Exception as e:
                     print(f"Error running agent on task {task_id}, attempt {attempt+1}: {e}")
                     if "rate limit" in str(e).lower() and attempt < max_retries - 1:
-                        # Add jitter to avoid synchronized retries
-                        wait_time = (attempt + 1) * 15 + random.uniform(0, 5)
+                        # Exponential backoff with jitter
+                        wait_time = (2 ** attempt) * 5 + random.uniform(0, 3)
                         print(f"Rate limit hit. Waiting {wait_time:.2f} seconds before retry...")
                         await asyncio.sleep(wait_time)
                     elif attempt < max_retries - 1:
-                        await asyncio.sleep(10)  # Wait before general retry
+                        await asyncio.sleep(5)  # Reduced wait time
                     else:
                         # All retries failed, return default answer
                         default_answer = "This is a default answer."