native gemini tooling

app.py

@@ -1,166 +1,112 @@
 import os
 import gradio as gr
 import requests
-import inspect
-import pandas as pd
-import google.generativeai as genai
 import re
 import time
-from google.api_core import exceptions
+import pandas as pd
+import google.generativeai as genai
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-MAX_ITERATIONS = 7
-MAX_RETRIES = 5
 
-# --- Tool Definitions (Unchanged) ---
-class WebSearchTool:
-    def __init__(self, api_key):
-        self.api_key = api_key
-        self.url = "https://api.perplexity.ai/chat/completions"
-    def execute(self, query: str) -> str:
-        print(f"Executing WebSearchTool with query: {query}")
-        payload = {"model": "llama-3-sonar-small-32k-online", "messages": [{"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}]}
-        headers = {"accept": "application/json", "content-type": "application/json", "Authorization": f"Bearer {self.api_key}"}
-        try:
-            response = requests.post(self.url, json=payload, headers=headers, timeout=40)
-            response.raise_for_status()
-            return response.json()['choices'][0]['message']['content']
-        except requests.exceptions.RequestException as e:
-            return f"Error: Could not get a response from the web search tool. {e}"
-
-class FileDownloaderTool:
-    def __init__(self, api_url: str):
-        self.api_url = api_url
-    def execute(self, task_id: str) -> str:
-        file_url = f"{self.api_url}/files/{task_id}"
-        try:
-            response = requests.get(file_url, timeout=20)
-            response.raise_for_status()
-            content = response.text
-            if len(content) > 5000: return f"File content (first 5000 chars):\n{content[:5000]}"
-            return f"File content:\n{content}"
-        except requests.exceptions.HTTPError as e:
-            if e.response.status_code == 404: return "No file is associated with this task."
-            return f"Error: Failed to download file due to an HTTP error: {e}"
-        except requests.exceptions.RequestException as e:
-            return f"Error: Failed to download file due to a network error: {e}"
-
-# --- GAIA Agent Definition ---
-class GAIAAgent:
-    def __init__(self, gemini_api_key: str, pplx_api_key: str, api_url: str):
-        print("Initializing GAIAAgent...")
+# --- New Native Gemini Agent ---
+class NativeGeminiAgent:
+    """
+    An agent that leverages Gemini's native multi-modal capabilities,
+    including grounding, video, and file understanding.
+    """
+    def __init__(self, gemini_api_key: str, api_url: str):
+        print("Initializing NativeGeminiAgent...")
         genai.configure(api_key=gemini_api_key)
         
-        # --- CORRECTING THE MODEL TO THE USER'S SPECIFICATION ---
-        self.model_name = 'gemini-2.5-pro-preview-06-05'
-        self.model = genai.GenerativeModel(self.model_name)
-        print(f"Agent equipped with user-specified model: {self.model_name}")
+        self.api_url = api_url
         
-        self.tools = {"WebSearch": WebSearchTool(api_key=pplx_api_key), "FileDownloader": FileDownloaderTool(api_url=api_url)}
-
-        self.zero_shot_prompt_template = """
-Analyze the following question. If the answer is self-contained in the question and requires no external tools, provide the answer directly and concisely. Otherwise, respond with the single word: UNSURE.
-
-Question: {question}
-Answer:"""
-
-        self.react_prompt_template = """
-You are a state-of-the-art reasoning agent. Your goal is to answer the user's question by creating a plan and executing it using the tools provided.
-
-**Tools Available:**
-- **WebSearch[query]**: Searches the web for information. Use different queries if initial results are not satisfactory.
-- **FileDownloader[task_id]**: Downloads a file for a specific task. The task_id is '{task_id}'.
-
-**Reasoning Format:**
-Thought: My reasoning process and plan to solve the question.
-Action: The tool I will use, in the format `ToolName[input]`.
-Observation: [The result from the tool will be inserted here]
-... (The Thought/Action/Observation cycle can repeat)
-Thought: I have sufficient information to provide the final answer.
-Final Answer: The definitive answer to the user's question.
-
-**Guiding Principles:**
-1.  **Persist:** Do not give up easily. If a search fails, re-evaluate and try a more specific or different query.
-2.  **Conclude:** Once you have the answer, state it clearly with `Final Answer:`.
-3.  **Fail Gracefully:** If, after several genuine attempts, you conclude the answer is unobtainable, state `Final Answer: I am unable to answer this question.`
-
-Question: {question}"""
-        print("GAIAAgent initialized with refined prompts for the specified model.")
-
-    def _call_gemini_api_with_backoff(self, prompt_text):
-        retries = 0
-        while retries < MAX_RETRIES:
-            try:
-                time.sleep(2) 
-                response = self.model.generate_content(prompt_text)
-                return response.text
-            except exceptions.ResourceExhausted as e:
-                wait_time = (2 ** retries) + 2
-                print(f"API Rate Limit Exceeded (429). Waiting for {wait_time}s to retry...")
-                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}"
-        return "AGENT_ERROR: API rate limit exceeded after multiple retries."
+        # Enable native grounding with Google Search
+        google_search_retrieval = genai.protos.Tool(
+            google_search_retrieval=genai.protos.GoogleSearchRetrieval(disable_attribution=False)
+        )
+        
+        # Configure the model with the native tool
+        self.model_name = 'gemini-1.5-pro-latest' # Using the best stable model
+        self.model = genai.GenerativeModel(
+            model_name=self.model_name,
+            tools=[google_search_retrieval],
+            # A more direct prompt, trusting the model's native abilities
+            system_instruction="You are a world-class problem solver. Your goal is to answer the user's question accurately. Use your tools and reasoning abilities to provide a definitive answer.",
+            # Safety settings dialed down to allow answering controversial topics if they appear in GAIA
+            safety_settings={
+                HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+            }
+        )
+        print(f"Agent equipped with {self.model_name} and native Google Search grounding.")
+
+    def _check_if_file_exists(self, url: str) -> bool:
+        """Checks if a remote file exists before sending it to Gemini."""
+        try:
+            response = requests.head(url, timeout=10)
+            return response.status_code == 200
+        except requests.exceptions.RequestException:
+            return False
 
     def __call__(self, question: str, task_id: str) -> str:
-        print(f"\n{'='*20}\nProcessing Task ID: {task_id}\nQuestion: {question[:100]}...")
-        print(f"--- Using model: {self.model_name} ---")
-
-        # 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" not in zero_shot_answer and "UNSURE" not in zero_shot_answer.upper():
-            print(f"Zero-shot successful! Answer: {zero_shot_answer}")
-            return zero_shot_answer
-
-        # Step 2: ReAct Loop
-        print("--- Zero-shot failed, starting ReAct loop ---")
-        current_prompt_history = self.react_prompt_template.format(question=question, task_id=task_id)
+        print(f"\n{'='*20}\nProcessing Task ID: {task_id}")
         
-        for i in range(MAX_ITERATIONS):
-            print(f"\n--- ReAct Iteration {i+1} ---")
-            response_text = self._call_gemini_api_with_backoff(current_prompt_history)
-            print(f"LLM Response:\n{response_text}")
-
-            if "AGENT_ERROR" in response_text: return response_text
-
-            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}")
-                return final_answer
+        # --- This is the core of the new multi-modal logic ---
+        # We build a list of "parts" to send to the model, not just a string.
+        prompt_parts = [question]
+        
+        # 1. Automatically find and add any URLs from the question text
+        urls_in_question = re.findall(r'https?://\S+', question)
+        if urls_in_question:
+            for url in urls_in_question:
+                print(f"Found URL in question: {url}")
+                prompt_parts.append(genai.Part.from_uri(uri=url, mime_type="video/mp4")) # Assume video for now, Gemini can handle it
+
+        # 2. Check for and add any associated files from the GAIA server
+        file_url = f"{self.api_url}/files/{task_id}"
+        if self._check_if_file_exists(file_url):
+            print(f"Found associated file, adding URL: {file_url}")
+            # We need to determine the mime type. Let's assume common ones for GAIA.
+            # A simple heuristic can be used, or we can try to guess from the URL.
+            mime_type = "image/jpeg" # Default, can be improved
+            if '.pdf' in file_url: mime_type = "application/pdf"
+            if '.txt' in file_url: mime_type = "text/plain"
+            prompt_parts.append(genai.Part.from_uri(uri=file_url, mime_type=mime_type))
+        else:
+            print("No associated file found for this task.")
+            
+        print(f"Sending {len(prompt_parts)} parts to the model.")
 
-            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()
-                if tool_name in self.tools:
-                    tool = self.tools[tool_name]
-                    try:
-                        observation = tool.execute(task_id if tool_name == "FileDownloader" else tool_input)
-                    except Exception as e: observation = f"Error executing tool: {e}"
-                    current_prompt_history += f"\n{response_text}\nObservation: {observation}"
-                else:
-                    current_prompt_history += f"\n{response_text}\nObservation: Error - The tool '{tool_name}' does not exist."
-            else:
-                return response_text.strip()
-        return "AGENT_ERROR: Agent reached max iterations."
+        try:
+            # Generate the response using the multi-modal prompt
+            response = self.model.generate_content(prompt_parts)
+            
+            # The grounding feature may add citations. We need to remove them for the final answer.
+            final_answer = re.sub(r'\[\d+\]', '', response.text).strip()
+            print(f"Model generated answer: {final_answer}")
+            return final_answer
+            
+        except Exception as e:
+            print(f"An error occurred while calling the Gemini API: {e}")
+            return f"AGENT_ERROR: Could not get a response from the model. Details: {e}"
 
-# --- Main run_and_submit_all function ---
+# --- Main run_and_submit_all function (largely the same, but simpler) ---
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID")
     if not profile: return "Please Login to Hugging Face with the button.", None
     username = f"{profile.username}"
 
     pplx_key, gemini_key = os.getenv("PPLX_API_KEY"), os.getenv("GEMINI_API_KEY")
-    if not pplx_key or not gemini_key: return "API keys not found in Space secrets.", None
+    if not gemini_key: return "CRITICAL ERROR: GEMINI_API_KEY not found in Space secrets.", None
     
     api_url = DEFAULT_API_URL
     try:
-        agent = GAIAAgent(gemini_api_key=gemini_key, pplx_api_key=pplx_key, api_url=api_url)
+        # We no longer need the Perplexity key for the agent
+        agent = NativeGeminiAgent(gemini_api_key=gemini_key, api_url=api_url)
         questions_data = requests.get(f"{api_url}/questions", timeout=15).json()
     except Exception as e: return f"Error during setup: {e}", None
 
@@ -173,10 +119,13 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             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:
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+             error_message = f"AGENT CRASH: {e}"
+             print(error_message)
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": error_message})
         
-        print(f"--- Waiting for 12 seconds before next question... ---")
-        time.sleep(12)
+        # API calls are now fewer but more complex. A delay is still wise.
+        print(f"--- Waiting for 10 seconds before next question... ---")
+        time.sleep(10)
 
     if not answers_payload: return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
     
@@ -195,10 +144,10 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     except requests.exceptions.RequestException as e:
         return f"Submission Failed: {e}", pd.DataFrame(results_log)
 
-# --- Gradio Interface (Unchanged) ---
+# --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner")
-    gr.Markdown("Equipped with the user-specified **gemini-2.5-pro-preview-06-05** model.")
+    gr.Markdown("# Native Multi-Modal GAIA Agent")
+    gr.Markdown("This agent uses Gemini 1.5 Pro with native Google Search grounding and direct multi-modal understanding (video, images, files).")
     gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit All Answers")
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)