Update app.py

app.py

@@ -98,382 +98,135 @@ def youtube_captions(self, url):
 from openai import OpenAI
 
 class BasicAgent:
-    
-
-    def read_audio(self, file):
-    
-        try:
-            model = whisper.load_model("base")
-    
-            result = model.transcribe(file)
-    
-            return result["text"]
-    
-        except:
-            return ""
-    def execute_tool(self, tool, input_data, file_url):
-
-        if tool == "wiki_search":
-            return self.wiki_search(input_data)
-    
-        if tool == "scrape_page":
-            return self.scrape_page(input_data)
-    
-        if tool == "read_excel":
-            file = self.download_file(file_url)
-            return self.read_excel(file)
-    
-        if tool == "read_image":
-            file = self.download_file(file_url)
-            return self.read_image(file)
-    
-        if tool == "calculator":
-            try:
-                return str(eval(input_data))
-            except:
-                return "error"
-    
-        return "unknown tool"
-    
-    def agent_loop(self, question, file_url):
-    
-        memory = ""
-    
-        for step in range(5):
-    
-            prompt = f"""
-    You are a GAIA solving agent.
-    
-    Available tools:
-    
-    1. read_excel(file_url)
-    2. read_image(file_url)
-    3. scrape_page(url)
-    4. youtube_captions(url)
-    5. calculator(expression)
-    6. wiki_search(query)
-    
-    Question:
-    {question}
-    
-    Previous steps:
-    {memory}
-    
-    Decide next action.
-    
-    Format:
-    
-    TOOL: tool_name
-    INPUT: tool_input
-    
-    OR
-    
-    FINAL: answer
-    """
-    
-            response = self.client.chat.completions.create(
-                model="gpt-4o-mini",
-                temperature=0,
-                messages=[{"role": "user", "content": prompt}]
-            )
-    
-            action = response.choices[0].message.content
-    
-            print("Agent step:", action)
-    
-            # FINAL ANSWER
-            if "FINAL:" in action:
-    
-                return action.split("FINAL:")[-1].strip()
-    
-            # TOOL CALL
-            if "TOOL:" in action:
-    
-                tool = action.split("TOOL:")[1].split("\n")[0].strip()
-    
-                input_data = action.split("INPUT:")[-1].strip()
-    
-                result = self.execute_tool(tool, input_data, file_url)
-    
-                memory += f"\nTool {tool} result:\n{result}\n"
-    
-        return "No answer found"
     def __init__(self):
         print("🚀 Super GAIA Agent initialized")
-        self.client = OpenAI()
-
-    # ------------------------------------------------
-    # Download file
-    # ------------------------------------------------
+        # Ensure your API Key is set in the Hugging Face Space Secrets
+        self.client = OpenAI() 
 
     def download_file(self, url):
-
+        if not url or not url.startswith("http"):
+            return None
         try:
-
             r = requests.get(url, timeout=20)
-
-            file_name = url.split("/")[-1]
-
+            file_name = url.split("/")[-1] or "temp_file"
             with open(file_name, "wb") as f:
                 f.write(r.content)
-
             return file_name
-
         except Exception as e:
-
-            print("Download error:", e)
-
+            print(f"Download error: {e}")
             return None
 
-    # ------------------------------------------------
-    # Excel parser
-    # ------------------------------------------------
-
-    def read_excel(self, file):
-
-        try:
-
-            df = pd.read_excel(file)
-
-            return df.to_string()
-
-        except Exception as e:
-
-            print("Excel error:", e)
-
-            return ""
-
-    # ------------------------------------------------
-    # Image OCR
-    # ------------------------------------------------
-
-    def read_image(self, file):
-
-        try:
-
-            img = Image.open(file)
-
-            text = pytesseract.image_to_string(img)
-
-            return text
-
-        except Exception as e:
-
-            print("OCR error:", e)
-
-            return ""
-
-    # ------------------------------------------------
-    # Web scraper
-    # ------------------------------------------------
-
-    def scrape_page(self, url):
-
-        try:
-
-            r = requests.get(url, timeout=20)
-
-            soup = BeautifulSoup(r.text, "html.parser")
-
-            text = soup.get_text()
-
-            return text[:6000]
-
-        except Exception as e:
-
-            print("Web error:", e)
-
-            return ""
-
-    # ------------------------------------------------
-    # Wikipedia search
-    # ------------------------------------------------
-
     def wiki_search(self, query):
-
         try:
-
-            url = f"https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch={query}&format=json"
-
+            # Clean query to avoid API errors
+            query = query.strip('"')
+            url = f"https://en.wikipedia.org{query}&format=json"
             r = requests.get(url).json()
-
+            if not r.get("query", {}).get("search"):
+                return "No wikipedia results found."
             title = r["query"]["search"][0]["title"]
-
-            page = requests.get(
-                f"https://en.wikipedia.org/api/rest_v1/page/summary/{title}"
-            ).json()
-
-            return page["extract"]
-
+            page = requests.get(f"https://en.wikipedia.org{title}").json()
+            return page.get("extract", "No summary available.")
         except:
+            return "Wikipedia search failed."
 
-            return ""
-
-    # ------------------------------------------------
-    # Python calculator
-    # ------------------------------------------------
-
-    def calculator(self, question):
-
+    def youtube_captions(self, url):
         try:
+            ydl_opts = {"skip_download": True, "writesubtitles": True, "writeautomaticsub": True}
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(url, download=False)
+            # Return first available captions
+            return str(info.get("subtitles") or info.get("automatic_captions"))[:5000]
+        except Exception as e:
+            return f"YouTube error: {e}"
 
-            expr = re.findall(r'[\d\.\+\-\*\/\(\)]+', question)
-
-            for e in expr:
-
-                if any(op in e for op in "+-*/"):
-
-                    result = eval(e, {"__builtins__": {}})
-
-                    return str(result)
-
-        except:
-            pass
-
-        return None
-
-    # ------------------------------------------------
-    # File loader
-    # ------------------------------------------------
-
-    def load_file(self, url):
-
-        if not url:
-            return ""
-
-        file = self.download_file(url)
-
-        if not file:
-            return ""
-
-        if file.endswith(".xlsx") or file.endswith(".xls"):
-
-            return self.read_excel(file)
-
-        if file.endswith(".png") or file.endswith(".jpg"):
-
-            return self.read_image(file)
-        if file.endswith(".mp3"):
-            return self.read_audio(file)
-        if file.endswith(".py"):
-
-            with open(file) as f:
-                return f.read()
-
-        try:
-
-            with open(file) as f:
-
-                return f.read()
-
-        except:
-
-            return ""
-
-    # ------------------------------------------------
-    # Clean answer
-    # ------------------------------------------------
-
-    def clean(self, text):
-
-        text = text.replace("Answer:", "")
-        text = text.replace("Final answer:", "")
-
-        text = text.strip()
-
-        text = text.replace("\n", " ")
-
-        return text
-
-    # ------------------------------------------------
-    # LLM reasoning
-    # ------------------------------------------------
-
-    def reason(self, question, file_content):
-
-        wiki_data = self.wiki_search(question)
-
-        prompt = f"""
-You are a powerful GAIA benchmark agent.
-
-You can:
-- read tables
-- analyze files
-- solve math
-- search wikipedia
-- extract OCR text
-
-QUESTION:
-{question}
-
-FILE CONTENT:
-{file_content}
-
-WIKIPEDIA DATA:
-{wiki_data}
-
-Solve the task carefully.
-
-If a list is requested, return the FULL list.
-
-Return ONLY the final answer.
-"""
-
-        response = self.client.chat.completions.create(
-
-            model="gpt-4o-mini",
-            temperature=0,
-
-            messages=[
-                {"role": "system", "content": "You are a highly capable reasoning agent."},
-                {"role": "user", "content": prompt}
-            ]
-        )
-
-        return response.choices[0].message.content
-
-    # ------------------------------------------------
-    # Extract final answer
-    # ------------------------------------------------
-
-    def extract(self, reasoning):
+    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."
+            
+            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."
+
+        # 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)
+                return BeautifulSoup(r.text, "html.parser").get_text()[:6000]
+            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=None):
+        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 ""
+        
+        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"""
-Extract the final answer from the text.
+Question: {question}
 
-Text:
-{reasoning}
+Current History:
+{memory}
 
-Return only the answer.
-"""
+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.
 
-        response = self.client.chat.completions.create(
+Format:
+TOOL: tool_name
+INPUT: tool_input
+OR
+FINAL: your_precise_answer"""
 
-            model="gpt-4o-mini",
-            temperature=0,
+            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."},
+                          {"role": "user", "content": prompt}]
+            )
+            
+            action = response.choices[0].message.content.strip()
+            print(f"Agent step: {action}")
 
-            messages=[{"role": "user", "content": prompt}]
-        )
+            if "FINAL:" in action:
+                # Extract only the content after FINAL:
+                return action.split("FINAL:")[-1].strip()
 
-        return response.choices[0].message.content
-
-    # ------------------------------------------------
-    # Main agent call
-    # ------------------------------------------------
-
-    def __call__(self, question, file_url=None):
-        if "youtube.com" in question or "youtu.be" in question:
-            captions = self.youtube_captions(question)
-            file_content = captions
-        else:
-            file_content = self.load_file(file_url)
-        print("Question:", question)
-    
-        answer = self.agent_loop(question, file_url)
-    
-        print("Final:", answer)
-    
-        return answer
+            if "TOOL:" in action:
+                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)}"
+            else:
+                # If the agent just talks without a tool or FINAL, treat as text
+                memory += f"\nStep {step}: {action}"
+        
+        return "No answer found"
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """