Update app.py

app.py

@@ -123,20 +123,20 @@ class BasicAgent:
     # --- Robust Wikipedia Tool ---
     def wiki_search(self, query):
         try:
-            # Step 1: Search for the most relevant page title
-            search_url = f"https://en.wikipedia.org{query}&format=json"
-            r = requests.get(search_url).json()
+            # Clean common AI hallucinations from the query
+            query = query.strip(' "').replace('TOOL:', '').replace('INPUT:', '')
+            url = f"https://en.wikipedia.org{query}&format=json"
+            r = requests.get(url, timeout=10).json()
             if not r.get("query", {}).get("search"):
-                return "No Wikipedia page found for this query."
+                return "No results found. Try a broader search term."
             
             title = r["query"]["search"][0]["title"]
-            
-            # Step 2: Get the summary of that specific page
+            # Fetch the actual content summary
             summary_url = f"https://en.wikipedia.org{title.replace(' ', '_')}"
-            page = requests.get(summary_url).json()
-            return page.get("extract", "Summary not available.")
-        except Exception as e:
-            return f"Wiki error: {str(e)}"
+            page = requests.get(summary_url, timeout=10).json()
+            return page.get("extract", "No summary available.")
+        except:
+            return "Wikipedia access error."
 
     def youtube_captions(self, url):
         try:
@@ -148,21 +148,36 @@ class BasicAgent:
         except Exception as e:
             return f"YouTube error: {e}"
 
-    def execute_tool(self, tool, input_data, file_url):
-        # 1. Handle tools that need the provided file_url
-        if tool in ["read_excel", "read_image"]:
-            target_url = file_url if file_url else input_data
-            local_file = self.download_file(target_url)
-            if not local_file: return "Error: Could not download file. Check if file_url is valid."
+     def execute_tool(self, tool, input_data, file_url):
+        # Clean input_data (remove extra quotes or labels)
+        input_data = input_data.strip(' "')
+
+        if tool == "read_image" or tool == "read_excel":
+            # GAIA Fix: If agent says "none", use the file_url provided by the system
+            target = file_url if (not input_data or input_data.lower() == "none") else input_data
+            if not target: return "Error: No file provided."
             
-            if tool == "read_excel":
-                try:
-                    return pd.read_excel(local_file).to_string()[:5000]
-                except: return "Excel read error."
-            if tool == "read_image":
-                try:
-                    return pytesseract.image_to_string(Image.open(local_file))
-                except: return "OCR read error."
+            try:
+                r = requests.get(target, timeout=15)
+                with open("temp_file", "wb") as f: f.write(r.content)
+                
+                if tool == "read_image":
+                    return pytesseract.image_to_string(Image.open("temp_file"))
+                else:
+                    return pd.read_excel("temp_file").to_string()[:5000]
+            except Exception as e:
+                return f"File tool error: {str(e)}"
+
+        if tool == "wiki_search": return self.wiki_search(input_data)
+        
+        if tool == "calculator":
+            try:
+                # Remove everything except math chars
+                expr = re.sub(r'[^\d\+\-\*\/\(\)\.]', '', input_data)
+                return str(eval(expr, {"__builtins__": {}}))
+            except: return "Calculation error."
+
+        return f"Tool {tool} not found."
 
         # 2. Handle web/search tools
         if tool == "wiki_search":
@@ -183,58 +198,49 @@ class BasicAgent:
             
         return "Unknown tool"
 
-    def agent_loop(self, question, file_url=None):
+    def agent_loop(self, question, file_url):
         memory = ""
-        # Provide the file_url explicitly in the prompt so the agent knows it exists
-        file_info = f"\nNote: A file is available for this task at: {file_url}" if file_url else ""
+        # Explicitly tell the agent about the file
+        context = f"A file for this task is located at: {file_url}" if file_url else "No file attached."
         
         for step in range(5):
-            prompt = f"""You are a GAIA solving agent. 
-Available tools: read_excel, read_image, scrape_page, youtube_captions, calculator, wiki_search.
-{file_info}
+            prompt = f"""You are a GAIA solver.
+Available tools: read_excel, read_image, wiki_search, calculator.
+{context}
 
 Question: {question}
+History: {memory}
 
-Current History:
-{memory}
-
-Instructions:
-1. If you need to read the provided file, use TOOL: read_excel or TOOL: read_image with INPUT: {file_url if file_url else 'none'}.
-2. Give a FINAL answer as soon as you have enough information.
-
-Format:
-TOOL: tool_name
-INPUT: tool_input
-OR
-FINAL: your_precise_answer"""
+If you have the answer, respond with FINAL: [answer].
+If you need to use a tool, respond with:
+TOOL: [tool_name]
+INPUT: [input_data]"""
 
             response = self.client.chat.completions.create(
                 model="gpt-4o-mini",
-                temperature=0,
-                messages=[{"role": "system", "content": "You are a helpful assistant that uses tools to solve tasks."},
+                temperature=0, # Crucial for accuracy
+                messages=[{"role": "system", "content": "You are a precise agent. For 'opposite' questions, think carefully. For files, use the provided URL."},
                           {"role": "user", "content": prompt}]
             )
             
-            action = response.choices[0].message.content.strip()
-            print(f"Agent step: {action}")
+            resp_text = response.choices[0].message.content.strip()
+            print(f"Step {step}: {resp_text}")
 
-            if "FINAL:" in action:
-                # Extract only the content after FINAL:
-                return action.split("FINAL:")[-1].strip()
+            if "FINAL:" in resp_text:
+                return resp_text.split("FINAL:")[-1].strip()
 
-            if "TOOL:" in action:
+            if "TOOL:" in resp_text and "INPUT:" in resp_text:
                 try:
-                    tool_part = action.split("TOOL:")[1].split("\n")[0].strip()
-                    input_part = action.split("INPUT:")[1].split("\n")[0].strip()
-                    result = self.execute_tool(tool_part, input_part, file_url)
-                    memory += f"\nStep {step}: Tool {tool_part} returned: {result[:1000]}"
-                except Exception as e:
-                    memory += f"\nStep {step}: Tool call error: {str(e)}"
+                    tool_name = re.search(r"TOOL:\s*(.*)", resp_text).group(1).split('\n')[0].strip()
+                    tool_input = re.search(r"INPUT:\s*(.*)", resp_text).group(1).strip()
+                    result = self.execute_tool(tool_name, tool_input, file_url)
+                    memory += f"\n- {tool_name} output: {result[:1000]}"
+                except:
+                    memory += "\n- Failed to parse tool call."
             else:
-                # If the agent just talks without a tool or FINAL, treat as text
-                memory += f"\nStep {step}: {action}"
+                memory += f"\n- {resp_text}"
         
-        return "No answer found"
+        return "No answer found."
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """