Update app.py

app.py

@@ -42,12 +42,12 @@ def read_image(file_path):
         return "Image read error"
 
 
-def read_audio(file_path):
-    try:
-        audio = AudioSegment.from_file(file_path)
-        return f"Audio length: {len(audio)} ms"
-    except:
-        return "Audio read error"
+#def read_audio(file_path):
+#    try:
+#        audio = AudioSegment.from_file(file_path)
+#        return f"Audio length: {len(audio)} ms"
+#    except:
+#        return "Audio read error"
         
 def execute_tool(self, tool, input_data, file_url):
 
@@ -106,7 +106,14 @@ class BasicAgent:
         print("🚀 Super GAIA Agent initialized")
         # Ensure your API Key is set in the Hugging Face Space Secrets
         self.client = OpenAI() 
-
+    def read_audio(self, file_url):
+        try:
+            r = requests.get(file_url, timeout=20)
+            with open("temp_audio.mp3", "wb") as f: f.write(r.content)
+            result = self.audio_model.transcribe("temp_audio.mp3")
+            return result
+        except Exception as e:
+            return f"Audio error: {str(e)}"
     def download_file(self, url):
         if not url or not url.startswith("http"):
             return None
@@ -123,29 +130,16 @@ class BasicAgent:
     # --- Robust Wikipedia Tool ---
     def wiki_search(self, query):
         try:
-            # Clean the query
             query = query.strip(' "').replace('TOOL:', '').replace('INPUT:', '')
-            # Step 1: Search for the page
             search_url = "https://en.wikipedia.org"
             params = {"action": "query", "list": "search", "srsearch": query, "format": "json"}
             r = requests.get(search_url, params=params, timeout=10).json()
-            
-            if not r.get("query", {}).get("search"):
-                return "No results. Try simpler keywords."
-
-            # Step 2: Get the top result's snippet and title
-            best_result = r["query"]["search"][0]
-            title = best_result["title"]
-            snippet = BeautifulSoup(best_result["snippet"], "html.parser").get_text()
-            
-            # Step 3: Get the page summary content
-            summary_url = f"https://en.wikipedia.org{title.replace(' ', '_')}"
-            sum_r = requests.get(summary_url, timeout=10).json()
-            extract = sum_r.get("extract", snippet)
-            
-            return f"Source: {title}\nContent: {extract}"
-        except Exception as e:
-            return f"Wiki error: {str(e)}"
+            if not r.get("query", {}).get("search"): return "No results."
+            title = r["query"]["search"][0]["title"]
+            sum_url = f"https://en.wikipedia.org{title.replace(' ', '_')}"
+            sum_r = requests.get(sum_url, timeout=10).json()
+            return f"Source: {title}\nContent: {sum_r.get('extract', 'No summary.')}"
+        except: return "Wiki error."
             
     def youtube_captions(self, url):
         try:
@@ -159,45 +153,30 @@ class BasicAgent:
 
     def execute_tool(self, tool, input_data, file_url):
         input_data = input_data.strip(' "')
+        # Use provided file_url if agent input is generic or missing
+        target = file_url if (not input_data or "http" not in input_data) else input_data
+
+        if tool == "read_audio": return self.read_audio(target)
         
-        # Tool: Image or Excel
         if tool in ["read_image", "read_excel"]:
-            target = file_url if (not input_data or "http" not in input_data) else input_data
-            if not target: return "Error: No file available for this task."
+            if not target: return "Error: No file URL."
             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"))
+                if tool == "read_image": return pytesseract.image_to_string(Image.open("temp_file"))
                 return pd.read_excel("temp_file").to_string()[:5000]
-            except Exception as e:
-                return f"File error: {str(e)}"
+            except Exception as e: return f"File error: {str(e)}"
 
-        if tool == "wiki_search":
-            return self.wiki_search(input_data)
-        
+        if tool == "wiki_search": return self.wiki_search(input_data)
         if tool == "calculator":
-            try:
-                expr = re.sub(r'[^\d\+\-\*\/\(\)\.]', '', input_data)
-                return str(eval(expr, {"__builtins__": {}}))
+            try: return str(eval(re.sub(r'[^\d\+\-\*\/\(\)\.]', '', input_data), {"__builtins__": {}}))
             except: return "Math error."
-
         return f"Tool {tool} not recognized."
 
-        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":
-            return self.wiki_search(input_data)
+
         if tool == "scrape_page":
             try:
                 r = requests.get(input_data, timeout=15)
@@ -205,60 +184,51 @@ class BasicAgent:
             except: return "Web scraping failed."
         if tool == "youtube_captions":
             return self.youtube_captions(input_data)
-        if tool == "calculator":
-            try:
-                # Basic math security
-                clean = re.sub(r'[^\d\+\-\*\/\(\)\.]', '', input_data)
-                return str(eval(clean, {"__builtins__": {}}))
-            except: return "Math error."
-            
-        return "Unknown tool"
+
 
     def agent_loop(self, question, file_url):
         memory = ""
         context = f"File URL: {file_url}" if file_url else "No file provided."
         
         for step in range(5):
-            prompt = f"""You are a GAIA solver. Use tools only when necessary.
-Available tools: wiki_search, read_image, read_excel, calculator.
+            # Updated system prompt to handle botanical "trap" questions
+            prompt = f"""You are a GAIA solver. 
 {context}
-
 Question: {question}
-History: {memory}
 
-Output Format:
+IMPORTANT: 
+- If asked for 'vegetables' botanically, remember that anything with seeds (tomatoes, peppers, beans, corn, zucchini, cucumbers) is a FRUIT.
+- Available tools: wiki_search, read_image, read_excel, read_audio, calculator.
+- History: {memory}
+
+Format:
 TOOL: tool_name
 INPUT: tool_input
 OR
-FINAL: your_answer"""
+FINAL: answer"""
 
             response = self.client.chat.completions.create(
                 model="gpt-4o-mini",
                 temperature=0,
-                messages=[{"role": "system", "content": "Be concise. If you see a file URL in context, use it for 'read' tools."},
+                messages=[{"role": "system", "content": "You are a precise scientific agent. For audio tasks, use read_audio."},
                           {"role": "user", "content": prompt}]
             )
             
             resp = response.choices[0].message.content.strip()
             print(f"Step {step}: {resp}")
 
-            if "FINAL:" in resp:
-                return resp.split("FINAL:")[-1].strip()
+            if "FINAL:" in resp: return resp.split("FINAL:")[-1].strip()
 
-            # Robust Tool Parsing
             try:
                 t_match = re.search(r"TOOL:\s*(.*)", resp, re.I)
                 i_match = re.search(r"INPUT:\s*(.*)", resp, re.I)
-                
                 if t_match and i_match:
                     t_name = t_match.group(1).strip().lower()
                     t_input = i_match.group(1).strip()
                     result = self.execute_tool(t_name, t_input, file_url)
                     memory += f"\nStep {step} {t_name} output: {result[:800]}"
-                else:
-                    memory += f"\nStep {step} info: {resp}"
-            except:
-                memory += f"\nStep {step}: Parsing error."
+                else: memory += f"\nStep {step} info: {resp}"
+            except: memory += f"\nStep {step}: Parsing error."
         
         return "No answer found."