Update app.py

app.py

@@ -39,10 +39,10 @@ class GeminiReActAgent:
         
         # Direct REST API endpoint for Gemini 2.5 Flash
         self.url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key={self.api_key}"
-        print("Vanilla ReAct Gemini Agent initialized.")
+        print("Vanilla ReAct Gemini Agent initialized with rate-limit handling.")
 
     def call_gemini(self, history) -> str:
-        """Helper to make direct HTTP requests to the Gemini API."""
+        """Helper to make direct HTTP requests to the Gemini API with strict time pacing."""
         payload = {
             "contents": history,
             "generationConfig": {
@@ -51,78 +51,91 @@ class GeminiReActAgent:
                 "stopSequences": ["Observation:"] 
             }
         }
-        try:
-            response = requests.post(self.url, json=payload, timeout=20)
-            response.raise_for_status()
-            data = response.json()
-            return data["candidates"][0]["content"]["parts"][0]["text"].strip()
-        except Exception as e:
-            print(f"Gemini API Error: {e}")
-            if hasattr(e, 'response') and e.response is not None:
-                print(e.response.text)
-            return "Error"
+        
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                # ENFORCED TIME PACING: Wait 15 seconds to stay under the 5 Requests Per Minute limit.
+                print("  -> Pacing API: Sleeping for 15 seconds to respect 5 RPM limit...")
+                time.sleep(15) 
+                
+                response = requests.post(self.url, json=payload, timeout=20)
+                
+                # Check if we hit a 429
+                if response.status_code == 429:
+                    print(f"  -> WARNING: Rate limit hit (429). Entering 60-second cooldown... (Attempt {attempt + 1}/{max_retries})")
+                    time.sleep(60)
+                    continue 
+                
+                response.raise_for_status()
+                data = response.json()
+                return data["candidates"][0]["content"]["parts"][0]["text"].strip()
+                
+            except requests.exceptions.RequestException as e:
+                print(f"Gemini API Network Error: {e}")
+                if hasattr(e, 'response') and e.response is not None:
+                    print(e.response.text)
+                time.sleep(10)
+            except Exception as e:
+                print(f"Unexpected Error parsing Gemini response: {e}")
+                return "Error"
+                
+        return "Error"
 
     def __call__(self, question: str) -> str:
-        print(f"Agent processing question: {question[:50]}...")
+        print(f"\nAgent processing question: {question[:50]}...")
         
         system_instruction = """You are an expert assistant for the GAIA benchmark. 
 You must provide a short, factual, direct answer. No explanations.
-You have access to a Wikipedia search tool to find current facts.
+You have access to a Wikipedia search tool, but you also have vast internal knowledge.
 
-To use the tool, you MUST output exactly this format:
-Thought: <your reasoning>
+CRITICAL RULES:
+1. If the question asks you to categorize, sort, or use logic, use your internal knowledge immediately to output the Final Answer. Do not use tools.
+2. If the question mentions an attached image, video, audio, or Excel/CSV file, do your best to answer based purely on the text provided or by searching the internet. Do NOT say "I cannot analyze this."
+3. You must output EXACTLY one of the two formats below. 
+
+FORMAT 1 (To use the search tool):
+Thought: <what you need to search>
 Action: Search
-Action Input: <search query>
+Action Input: <short, specific search query>
 
-If you know the answer or have found it from the search, output exactly:
-Thought: <final reasoning>
+FORMAT 2 (To give the final answer):
+Thought: <your reasoning>
 Final Answer: <the short, direct answer>"""
 
-        # Initialize conversation state
         history = [
             {"role": "user", "parts": [{"text": system_instruction + "\n\nQuestion: " + question}]}
         ]
 
-        # The ReAct Loop (Max 5 iterations to prevent infinite loops)
         for iteration in range(5):
-            time.sleep(1) # Pace requests to respect API limits
-            
             reply = self.call_gemini(history)
             
             if reply == "Error":
                 return "0"
 
-            # Add model's reply to history
             history.append({"role": "model", "parts": [{"text": reply}]})
 
-            # 1. Check if the model arrived at the final answer
             if "Final Answer:" in reply:
                 answer = reply.split("Final Answer:")[-1].strip()
                 return answer if answer else "0"
             
-            # 2. Check if the model wants to use the Search tool
             elif "Action: Search" in reply and "Action Input:" in reply:
                 query_lines = [line for line in reply.split('\n') if "Action Input:" in line]
                 if query_lines:
                     query = query_lines[0].split("Action Input:")[-1].strip()
                     observation = search_wikipedia(query)
-                    
-                    # Feed the search results back into the model's context
                     history.append({"role": "user", "parts": [{"text": observation}]})
                     continue
             
-            # 3. Fallback if the model breaks formatting
             else:
                 history.append({
                     "role": "user", 
                     "parts": [{"text": "Format error. Please use 'Action: Search' or 'Final Answer:'"}]
                 })
         
-        # Fallback if loops exhaust
         return "0"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") 
 
     if profile:
@@ -136,7 +149,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 = GeminiReActAgent()
     except Exception as e:
@@ -144,58 +156,40 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return f"Error initializing agent: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(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
 
-    # 3. Run your Agent
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
+    
     for item in questions_data:
         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:
             submitted_answer = agent(question_text)
             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}"})
 
     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)
+    print(f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'...")
 
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -207,49 +201,21 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
         results_df = pd.DataFrame(results_log)
         return final_status, results_df
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
-        try:
-            error_json = e.response.json()
-            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        status_message = f"Submission Failed: {error_detail}"
-        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)
+        status_message = f"Submission Failed: {e}"
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Gemini Agent Evaluation Runner")
+    gr.Markdown("# Gemini Rate-Limited Agent Evaluation")
     gr.Markdown(
         """
-        **Instructions:**
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-        ---
         **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        Due to Google's strict Free Tier rate limit (5 requests per minute), the agent forces a 15-second delay before every API call. 
+        **This process will take roughly 15 to 25 minutes to complete 20 questions.** Please click 'Submit' and do not refresh the page.
         """
     )
     gr.LoginButton()
@@ -263,21 +229,4 @@ with gr.Blocks() as demo:
 
 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}")
-        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
-    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}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
-    else:
-        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
-    print("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for Gemini Agent Evaluation...")
     demo.launch(debug=True, share=False)