rate limit avoiding

app.py

@@ -6,12 +6,14 @@ import pandas as pd
 import google.generativeai as genai
 import re
 import time
+from google.api_core import exceptions
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MAX_ITERATIONS = 7 # Set a limit to prevent infinite loops
+MAX_ITERATIONS = 7 # Max steps in the ReAct loop
+MAX_RETRIES = 5 # NEW: Max retries for API calls
 
-# --- Tool Definitions ---
+# --- Tool Definitions (No changes here, kept for completeness) ---
 
 class WebSearchTool:
     """
@@ -28,7 +30,8 @@ class WebSearchTool:
         payload = {
             "model": "llama-3-sonar-small-32k-online",
             "messages": [
-                {"role": "system", "content": "You are an assistant that provides a concise and factual answer to the user's query."},
+                # MODIFIED: A slightly better prompt for GAIA-style questions
+                {"role": "system", "content": "You are a world-class research assistant. Answer the user's query based on verifiable public information. Be precise and comprehensive."},
                 {"role": "user", "content": query}
             ]
         }
@@ -63,10 +66,8 @@ class FileDownloaderTool:
         try:
             response = requests.get(file_url, timeout=20)
             response.raise_for_status()
-            # Assuming the file content is text
             content = response.text
             print(f"FileDownloaderTool successfully read file for task {task_id}. Content length: {len(content)}")
-            # Return a summary or a portion if the content is too long
             if len(content) > 5000:
                 return f"File content (first 5000 chars):\n{content[:5000]}"
             return f"File content:\n{content}"
@@ -86,18 +87,27 @@ class FileDownloaderTool:
 class GAIAAgent:
     def __init__(self, gemini_api_key: str, pplx_api_key: str, api_url: str):
         print("Initializing GAIAAgent...")
-        # Configure Gemini
         genai.configure(api_key=gemini_api_key)
         self.model = genai.GenerativeModel('gemini-1.5-flash-latest')
 
-        # Initialize Tools
         self.tools = {
             "WebSearch": WebSearchTool(api_key=pplx_api_key),
             "FileDownloader": FileDownloaderTool(api_url=api_url),
         }
         
-        # Define the ReAct prompt template
-        self.prompt_template = """
+        # MODIFIED: A simpler prompt for the initial zero-shot check
+        self.zero_shot_prompt_template = """
+You are a helpful assistant. Your job is to answer the user's question directly and concisely.
+Do not explain your reasoning.
+Do not use tools.
+If you can answer the question with high confidence, provide the answer.
+If the question requires browsing the web, accessing a file, or performing complex calculations, respond with the single word: "UNSURE".
+
+Question: {question}
+Answer:
+"""
+
+        self.react_prompt_template = """
 You are a helpful assistant designed to answer questions accurately.
 
 To solve the user's question, you must use a sequence of thoughts and actions.
@@ -111,7 +121,6 @@ Your reasoning process should follow this format:
 Thought: I need to figure out what information is missing. I will use a tool to find it.
 Action: ToolName[input for the tool]
 Observation: [The result from the tool will be inserted here]
-
 ... (this Thought/Action/Observation cycle can repeat multiple times)
 
 Thought: I have now gathered enough information to answer the user's question.
@@ -120,46 +129,68 @@ Final Answer: The final answer to the original question.
 **Important Rules:**
 1. The `Action` line must be *exactly* in the format `ToolName[input]`. For example: `WebSearch[When was the Eiffel Tower built?]`.
 2. The `task_id` for the current question is '{task_id}'. Use it ONLY with the FileDownloader tool.
-3. If no file is associated with the task, the FileDownloader tool will return 'No file is associated with this task.'.
-4. Once you have the final answer, do not use any more tools. State the final answer clearly after "Final Answer:".
+3. Once you have the final answer, do not use any more tools. State the final answer clearly after "Final Answer:". Your entire response should end here.
 
 Here is the question:
 {question}
 """
         print("GAIAAgent initialized successfully.")
 
+    # NEW: Function to handle API calls with exponential backoff
+    def _call_gemini_api_with_backoff(self, prompt_text):
+        retries = 0
+        while retries < MAX_RETRIES:
+            try:
+                print(f"Attempt {retries + 1} to call Gemini API...")
+                response = self.model.generate_content(prompt_text)
+                return response.text
+            except exceptions.ResourceExhausted as e:
+                print(f"API Rate Limit Exceeded (429). Waiting to retry... ({e.message})")
+                wait_time = (2 ** retries) + 1 # Exponential backoff: 2, 3, 5, 9, 17 seconds
+                time.sleep(wait_time)
+                retries += 1
+            except Exception as e:
+                print(f"An unexpected error occurred with Gemini API: {e}")
+                return f"AGENT_ERROR: An unexpected error occurred: {e}"
+        
+        print("Max retries reached. Failing.")
+        return "AGENT_ERROR: API rate limit exceeded after multiple retries."
+
     def __call__(self, question: str, task_id: str) -> str:
-        print(f"Agent received question for task {task_id}: {question[:100]}...")
+        print(f"\n{'='*20}\nProcessing Task ID: {task_id}\nQuestion: {question[:100]}...")
 
-        # Format the initial prompt with the question and task_id
-        prompt = self.prompt_template.format(question=question, task_id=task_id)
+        # === NEW: Step 1 - Zero-Shot Attempt ===
+        print("--- Step 1: Zero-Shot Attempt ---")
+        zero_shot_prompt = self.zero_shot_prompt_template.format(question=question)
+        zero_shot_answer = self._call_gemini_api_with_backoff(zero_shot_prompt).strip()
+
+        if "AGENT_ERROR" in zero_shot_answer:
+            return zero_shot_answer # Propagate API failure
+        
+        if "UNSURE" not in zero_shot_answer.upper():
+            print(f"Zero-shot successful! Answer: {zero_shot_answer}")
+            return zero_shot_answer
+
+        # === MODIFIED: Step 2 - ReAct Loop ===
+        print("--- Step 2: Zero-shot failed, starting ReAct loop ---")
+        react_prompt = self.react_prompt_template.format(question=question, task_id=task_id)
         
-        # Start the ReAct loop
         for i in range(MAX_ITERATIONS):
-            print(f"\n--- Iteration {i+1} ---")
+            print(f"\n--- ReAct Iteration {i+1} ---")
             
-            try:
-                print("Generating response from Gemini...")
-                # Add a small delay to avoid hitting rate limits too quickly
-                time.sleep(1)
-                response = self.model.generate_content(prompt)
-                response_text = response.text
-                print(f"LLM Response:\n{response_text}")
+            response_text = self._call_gemini_api_with_backoff(react_prompt)
+            print(f"LLM Response:\n{response_text}")
 
-            except Exception as e:
-                print(f"Error calling Gemini API: {e}")
-                return f"Error: Could not get a response from the reasoning model. {e}"
+            if "AGENT_ERROR" in response_text:
+                return response_text # Propagate API failure
 
-            # Check for Final Answer
             final_answer_match = re.search(r"Final Answer:\s*(.*)", response_text, re.DOTALL)
             if final_answer_match:
                 final_answer = final_answer_match.group(1).strip()
                 print(f"Found Final Answer: {final_answer}")
-                # Per instructions, return only the answer itself
                 return final_answer
 
-            # Check for Action
-            action_match = re.search(r"Action:\s*(\w+)\[(.*?)\]", response_text)
+            action_match = re.search(r"Action:\s*(\w+)\[(.*?)\]", response_text, re.DOTALL)
             if action_match:
                 tool_name = action_match.group(1).strip()
                 tool_input = action_match.group(2).strip()
@@ -168,7 +199,6 @@ Here is the question:
                     print(f"Executing tool '{tool_name}' with input '{tool_input}'")
                     tool = self.tools[tool_name]
                     try:
-                        # Special handling for FileDownloader which needs task_id
                         if tool_name == "FileDownloader":
                             observation = tool.execute(task_id)
                         else:
@@ -176,26 +206,20 @@ Here is the question:
                     except Exception as e:
                         observation = f"Error executing tool: {e}"
                     
-                    # Append the observation to the prompt for the next turn
-                    prompt += f"{response_text}\nObservation: {observation}\n"
+                    react_prompt += f"{response_text}\nObservation: {observation}\n"
                 else:
                     print(f"Error: Agent tried to use an unknown tool: {tool_name}")
-                    prompt += f"{response_text}\nObservation: Error - The tool '{tool_name}' does not exist. Available tools are: {list(self.tools.keys())}.\n"
+                    react_prompt += f"{response_text}\nObservation: Error - The tool '{tool_name}' does not exist.\n"
             else:
-                print("Error: Agent did not provide a valid Action or Final Answer. Ending loop.")
-                # If the model just gives a response without the proper format, return it as a last resort.
+                print("Error: Agent did not provide a valid Action or Final Answer. Returning last response.")
                 return response_text.strip()
 
         print("Agent reached max iterations without finding a final answer.")
-        return "Agent could not determine the answer within the allowed number of steps."
+        return "AGENT_ERROR: Agent could not determine the answer within the allowed number of steps."
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the GAIAAgent on them, submits all answers,
-    and displays the results.
-    """
-    # --- Determine HF Space Runtime URL and Repo URL ---
+    # This function is mostly the same, with one key change added.
     space_id = os.getenv("SPACE_ID")
 
     if profile:
@@ -205,12 +229,11 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print("User not logged in.")
         return "Please Login to Hugging Face with the button.", None
 
-    # --- Get API Keys from Secrets ---
     pplx_key = os.getenv("PPLX_API_KEY")
     gemini_key = os.getenv("GEMINI_API_KEY")
 
     if not pplx_key or not gemini_key:
-        error_msg = "API keys not found in Space secrets. Please set PPLX_API_KEY and GEMINI_API_KEY in your Space settings."
+        error_msg = "API keys not found in Space secrets. Please set PPLX_API_KEY and GEMINI_API_KEY."
         print(error_msg)
         return error_msg, None
     
@@ -218,7 +241,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
     try:
         agent = GAIAAgent(gemini_api_key=gemini_key, pplx_api_key=pplx_key, api_url=api_url)
     except Exception as e:
@@ -228,28 +250,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(f"Agent code link: {agent_code}")
 
-    # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
              return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
-    except requests.exceptions.JSONDecodeError as e:
-         print(f"Error decoding JSON response from questions endpoint: {e}")
-         print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
     except Exception as e:
-        print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return f"Error fetching questions: {e}", None
 
-    # 3. Run your Agent
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
@@ -257,30 +267,29 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            # Pass both question and task_id to the agent
             submitted_answer = agent(question_text, task_id)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
              print(f"Error running agent on task {task_id}: {e}")
              results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+        
+        # NEW: Add a delay between each question to respect rate limits
+        print(f"--- Waiting for 5 seconds before next question... ---")
+        time.sleep(5)
 
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
-    # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120) # Increased timeout for submission
+        response = requests.post(submit_url, json=submission_data, timeout=120)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
@@ -304,24 +313,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
-    except requests.exceptions.Timeout:
-        status_message = "Submission Failed: The request timed out."
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
-    except requests.exceptions.RequestException as e:
-        status_message = f"Submission Failed: Network error - {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
     except Exception as e:
         status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-
-# --- Build Gradio Interface using Blocks ---
+# --- Gradio Interface (No changes here) ---
 with gr.Blocks() as demo:
     gr.Markdown("# GAIA Agent Evaluation Runner")
     gr.Markdown(
@@ -332,42 +330,18 @@ with gr.Blocks() as demo:
         3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
         ---
         **Disclaimers:**
-        This process can take a significant amount of time (10-20 minutes) as the agent processes each of the 20 questions. The UI will be blocked during this time. Please be patient.
+        This process will now be slower due to the added delays to respect API rate limits, but it should be much more reliable. Please be patient.
         """
     )
-
     gr.LoginButton()
-
     run_button = gr.Button("Run Evaluation & Submit All Answers")
-
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    # Add the profile object from the LoginButton to the click function's inputs
     run_button.click(
         fn=run_and_submit_all,
-        # The login button automatically provides the profile object to functions that need it.
-        # We just need to ensure the function signature matches.
         outputs=[status_output, results_table]
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-
-    if space_host_startup:
-        print(f"✅ SPACE_HOST found: {space_host_startup}")
-    else:
-        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
-
-    if space_id_startup:
-        print(f"✅ SPACE_ID found: {space_id_startup}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?).")
-
-    print("-"*(60 + len(" App Starting ")) + "\n")
-
     print("Launching Gradio Interface for GAIA Agent Evaluation...")
     demo.launch(debug=True, share=False)