Update app.py

app.py

@@ -5,33 +5,34 @@ import inspect
 import pandas as pd
 import io
 import contextlib
-import traceback  # <-- Added for detailed errors
-from typing import TypedDict, Annotated, List  # <-- Added List
+import traceback
+from typing import TypedDict, Annotated, List
 import torch
 import json
-import re  # <-- Added for robust parsing
-import uuid # <-- Added for robust parsing
+import re
+import uuid
+import time
 
 # --- Multimodal & Web Tool Imports ---
 from transformers import pipeline
 from youtube_transcript_api import YouTubeTranscriptApi
-import requests
 from bs4 import BeautifulSoup
 
 # --- LangChain & LangGraph Imports ---
 from langgraph.graph.message import add_messages
-from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage, SystemMessage, ToolCall # <-- Ensure ToolCall is imported
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, ToolMessage, SystemMessage, ToolCall
 from langgraph.prebuilt import ToolNode
 from langgraph.graph import START, END, StateGraph
 from langchain_community.tools import DuckDuckGoSearchRun
-from langchain_core.tools import tool, BaseTool
+from langchain_core.tools import tool
 from langchain_groq import ChatGroq
 
 # --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space" # Still not working
-MAX_TURNS = 15 # <-- Added turn limit
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+MAX_TURNS = 20  # Increased from 15 for complex questions
+MAX_MESSAGE_LENGTH = 8000  # Truncate long outputs
 
-# --- Initialize ASR Pipeline (Keep as is) ---
+# --- Initialize ASR Pipeline ---
 asr_pipeline = None
 try:
     print("Loading ASR (Whisper) pipeline globally...")
@@ -47,46 +48,60 @@ try:
     print("✅ ASR (Whisper) pipeline loaded successfully.")
 except Exception as e:
     print(f"⚠️ Warning: Could not load ASR pipeline globally. Error: {e}")
-    traceback.print_exc()
     asr_pipeline = None
 
 # ====================================================
-# --- Tool Definitions (Standalone Functions) ---
+# --- Tool Definitions ---
+
 @tool
 def search_tool(query: str) -> str:
     """Calls DuckDuckGo search and returns the results. Use this for recent information or general web searches."""
-    # --- Input Validation ---
     if not isinstance(query, str) or not query.strip():
         return "Error: Invalid input. 'query' must be a non-empty string."
-    # --- End Validation ---
+    
     print(f"--- Calling Search Tool with query: {query} ---")
     try:
         search = DuckDuckGoSearchRun()
-        return search.run(query)
+        result = search.run(query)
+        # Truncate if too long
+        if len(result) > MAX_MESSAGE_LENGTH:
+            result = result[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(result)} total chars]"
+        return result
     except Exception as e:
-        # --- Granular Error ---
         tb_str = traceback.format_exc()
         print(f"--- Search Tool FAILED ---\n{tb_str}\n---")
-        return f"Error running search for '{query}': {str(e)}\nTraceback:\n{tb_str}"
+        return f"Error running search for '{query}': {str(e)}"
+
 
 @tool
 def code_interpreter(code: str) -> str:
     """
     Executes a string of Python code and returns its stdout, stderr, and any error.
-    Use for calculations, data manipulation (pandas), logic puzzles.
-    RULES:
-    1. ALWAYS use print() for final results.
-    2. Write simple, single-step scripts. Use plan text output to plan next steps.
-    3. Write reasoning as Python comments (#) before code.
-    'pandas' (as pd) is available.
+    Use for calculations, data manipulation (pandas), logic puzzles, file processing.
+    CRITICAL RULES:
+    1. ALWAYS use print() to output your final answer.
+    2. Write simple, focused code. One task per execution.
+    3. Add comments (#) to explain your logic.
+    Available: pandas as pd, basic Python libraries.
     """
-    # --- Input Validation ---
-    if not isinstance(code, str): # Basic check, could add more (e.g., length)
+    if not isinstance(code, str):
         return "Error: Invalid input. 'code' must be a string."
-    # --- End Validation ---
-    print(f"--- Calling Code Interpreter with code:\n{code}\n---")
+    
+    # Basic safety checks
+    dangerous_patterns = ['__import__', 'eval(', 'compile(', 'subprocess', 'os.system']
+    code_lower = code.lower()
+    for pattern in dangerous_patterns:
+        if pattern in code_lower:
+            return f"Error: Potentially dangerous operation '{pattern}' is not allowed."
+    
+    # Check for file writing in code
+    if 'open(' in code_lower and any(mode in code for mode in ["'w'", '"w"', "'a'", '"a"', "'wb'", '"wb"']):
+        return "Error: Writing files is not allowed in code_interpreter. Use write_file tool instead."
+    
+    print(f"--- Calling Code Interpreter ---\nCode:\n{code}\n---")
     output_stream = io.StringIO()
     error_stream = io.StringIO()
+    
     try:
         with contextlib.redirect_stdout(output_stream), contextlib.redirect_stderr(error_stream):
             safe_globals = {
@@ -94,196 +109,372 @@ def code_interpreter(code: str) -> str:
                 "__builtins__": __builtins__
             }
             exec(code, safe_globals, {})
-        stdout = output_stream.getvalue(); stderr = error_stream.getvalue()
-        if stderr: return f"Error: {stderr}\nStdout: {stdout}"
-        if stdout: return f"Success:\n{stdout}"
-        return "Success: Code executed without error and produced no stdout."
+            
+        stdout = output_stream.getvalue()
+        stderr = error_stream.getvalue()
+        
+        if stderr:
+            return f"Error in execution:\n{stderr}\n\nStdout (if any):\n{stdout}"
+        
+        if stdout:
+            # Truncate if too long
+            if len(stdout) > MAX_MESSAGE_LENGTH:
+                stdout = stdout[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(stdout)} total chars]"
+            return f"Success:\n{stdout}"
+        
+        return "Success: Code executed without error but produced no output.\n⚠️ Remember to use print() to output your results!"
+        
     except Exception as e:
-        # --- Granular Error with Traceback ---
         tb_str = traceback.format_exc()
         print(f"--- Code Interpreter FAILED ---\n{tb_str}\n---")
-        return f"Execution failed with error:\n{tb_str}"
+        error_msg = f"Execution failed:\n{tb_str}\n\n💡 Hints:\n- Check your syntax\n- Ensure you're using print() for output\n- Verify variable names and types"
+        return error_msg
+
 
 @tool
 def read_file(path: str) -> str:
-    """Reads the content of a file at the specified path relative to the app's CWD. Use this to examine files provided."""
-    # --- 1. Stricter Input Validation ---
+    """Reads the content of a file at the specified path. Use this to examine uploaded files or files you've created."""
     if not isinstance(path, str) or not path.strip():
         return "Error: Invalid input. 'path' must be a non-empty string."
-    # --- End Validation ---
-    print(f"--- Calling Read File Tool at path: {path} ---")
+    
+    print(f"--- Calling Read File Tool: {path} ---")
+    
     try:
-        # --- Path Finding Logic ---
         script_dir = os.getcwd()
-        print(f"Base directory for reading: {script_dir}")
-        safe_path = os.path.normpath(path) # Normalize path
-        full_path = os.path.join(script_dir, safe_path)
-        print(f"Attempting to read relative path: {full_path}")
-        if not os.path.exists(full_path):
-             full_path = safe_path # Try direct/absolute
-             print(f"Attempting to read direct/absolute path: {full_path}")
-             if not os.path.exists(full_path):
-                  base_path = os.path.basename(safe_path)
-                  cwd_base_path = os.path.join(os.getcwd(), base_path)
-                  print(f"Attempting to read basename path in CWD: {cwd_base_path}")
-                  if os.path.exists(cwd_base_path):
-                      full_path = cwd_base_path
-                  else:
-                      # --- 2a. Granular Error: File Not Found ---
-                      try: cwd_files = os.listdir(".")
-                      except Exception as list_e: cwd_files = [f"Error listing CWD: {list_e}"]
-                      return (f"Error: File not found.\n"
-                              f"Tried relative: '{os.path.join(script_dir, safe_path)}'\n"
-                              f"Tried direct/absolute: '{safe_path}'\n"
-                              f"Tried basename in CWD: '{cwd_base_path}'\n"
-                              f"Files in CWD (.): {cwd_files}")
+        safe_path = os.path.normpath(path)
+        
+        # Try multiple path strategies
+        paths_to_try = [
+            os.path.join(script_dir, safe_path),  # Relative to CWD
+            safe_path,  # Direct/absolute
+            os.path.join(os.getcwd(), os.path.basename(safe_path))  # Basename in CWD
+        ]
+        
+        full_path = None
+        for attempt_path in paths_to_try:
+            if os.path.exists(attempt_path):
+                full_path = attempt_path
+                break
+        
+        if not full_path:
+            try:
+                cwd_files = os.listdir(".")
+            except Exception:
+                cwd_files = ["(could not list)"]
+            return (f"Error: File not found: '{path}'\n"
+                   f"Tried paths:\n" + "\n".join(f"  - {p}" for p in paths_to_try) + 
+                   f"\n\nFiles in current directory: {cwd_files}")
+        
         print(f"Reading file: {full_path}")
-        # --- File Reading Logic with Specific Error Handling ---
+        
+        # Try to detect file type
+        _, ext = os.path.splitext(full_path)
+        
         try:
             with open(full_path, 'r', encoding='utf-8') as f:
-                return f.read()
-        # --- 2b. Granular Errors during file open/read ---
-        except FileNotFoundError:
-             return f"Error: File not found at final path '{full_path}'."
+                content = f.read()
+                
+            # Truncate if too long
+            if len(content) > MAX_MESSAGE_LENGTH:
+                content = content[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(content)} total chars]"
+            
+            return content
+            
+        except UnicodeDecodeError:
+            # Try binary read for non-text files
+            try:
+                with open(full_path, 'rb') as f:
+                    binary_content = f.read()
+                return f"File appears to be binary ({len(binary_content)} bytes). Cannot display as text.\nFile type: {ext}\nConsider using audio_transcription_tool for audio files."
+            except Exception as bin_e:
+                return f"Error: Could not read file as text or binary: {str(bin_e)}"
+                
         except PermissionError:
-            return f"Error: Permission denied when trying to read file '{full_path}'."
+            return f"Error: Permission denied reading '{full_path}'."
         except IsADirectoryError:
-             return f"Error: Specified path '{full_path}' is a directory, not a file."
-        except UnicodeDecodeError:
-             return f"Error: Could not decode file '{full_path}' as UTF-8. It might be binary or have a different encoding."
+            return f"Error: '{full_path}' is a directory, not a file. Use list_directory to see its contents."
         except Exception as read_e:
             tb_str = traceback.format_exc()
-            return f"Error reading file content from {full_path}: {str(read_e)}\nTraceback:\n{tb_str}"
+            return f"Error reading file: {str(read_e)}\n{tb_str}"
+            
     except Exception as e:
-        # --- 2c. Fallback for Unexpected Errors ---
         tb_str = traceback.format_exc()
-        print(f"--- Read File Tool FAILED UNEXPECTEDLY ---\n{tb_str}\n---")
-        return f"Unexpected error setting up file read for '{path}': {str(e)}\nTraceback:\n{tb_str}"
+        print(f"--- Read File Tool FAILED ---\n{tb_str}\n---")
+        return f"Unexpected error accessing file '{path}': {str(e)}"
+
 
-# --- (Keep write_file, list_directory, audio_transcription_tool, get_youtube_transcript, scrape_web_page as they were,
-#      but consider adding similar input validation and granular errors to them too) ---
 @tool
 def write_file(path: str, content: str) -> str:
-    """Writes the given content to a file at the specified path relative to the app's current directory. Creates directories if they don't exist."""
-    if not isinstance(path, str) or not path.strip(): return "Error: Invalid input. 'path' must be a non-empty string."
-    if not isinstance(content, str): return "Error: Invalid input. 'content' must be a string."
-    print(f"--- Calling Write File Tool at path: {path} ---")
+    """Writes content to a file at the specified path. Creates directories if needed."""
+    if not isinstance(path, str) or not path.strip():
+        return "Error: Invalid input. 'path' must be a non-empty string."
+    if not isinstance(content, str):
+        return "Error: Invalid input. 'content' must be a string."
+    
+    print(f"--- Calling Write File Tool: {path} ---")
+    
     try:
-        base_dir = os.getcwd(); full_path = os.path.join(base_dir, path)
-        print(f"Writing file to: {full_path}"); os.makedirs(os.path.dirname(full_path), exist_ok=True)
-        with open(full_path, 'w', encoding='utf-8') as f: f.write(content)
-        return f"Successfully wrote to file {path} (relative to CWD)."
-    except PermissionError: return f"Error: Permission denied writing to file '{full_path}'."
-    except Exception as e: tb_str = traceback.format_exc(); return f"Error writing to file {path}: {str(e)}\nTraceback:\n{tb_str}"
+        base_dir = os.getcwd()
+        full_path = os.path.join(base_dir, path)
+        
+        # Create directories if needed
+        dir_path = os.path.dirname(full_path)
+        if dir_path:
+            os.makedirs(dir_path, exist_ok=True)
+        
+        with open(full_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        return f"Successfully wrote {len(content)} characters to '{path}'."
+        
+    except PermissionError:
+        return f"Error: Permission denied writing to '{path}'."
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Error writing file '{path}': {str(e)}\n{tb_str}"
+
 
 @tool
 def list_directory(path: str = ".") -> str:
-    """Lists the contents (files and directories) of a directory at the specified path relative to the app's current directory."""
-    if not isinstance(path, str): return "Error: Invalid input. 'path' must be a string (or empty for current directory)."
-    print(f"--- Calling List Directory Tool at path: {path} ---")
+    """Lists the contents of a directory. Useful for finding available files."""
+    if not isinstance(path, str):
+        return "Error: Invalid input. 'path' must be a string."
+    
+    print(f"--- Calling List Directory Tool: {path} ---")
+    
     try:
-        base_dir = os.getcwd(); full_path = os.path.join(base_dir, path)
-        print(f"Listing directory: {full_path}")
-        if not os.path.isdir(full_path): return f"Error: '{path}' is not a valid directory relative to CWD."
-        files = os.listdir(full_path); return "\n".join(files) if files else "Directory is empty."
-    except FileNotFoundError: return f"Error: Directory not found at '{full_path}'."
-    except PermissionError: return f"Error: Permission denied listing directory '{full_path}'."
-    except Exception as e: tb_str = traceback.format_exc(); return f"Error listing directory {path}: {str(e)}\nTraceback:\n{tb_str}"
+        base_dir = os.getcwd()
+        full_path = os.path.join(base_dir, path) if path != "." else base_dir
+        
+        if not os.path.isdir(full_path):
+            return f"Error: '{path}' is not a valid directory."
+        
+        items = os.listdir(full_path)
+        
+        if not items:
+            return f"Directory '{path}' is empty."
+        
+        # Separate files and directories
+        files = []
+        directories = []
+        
+        for item in sorted(items):
+            item_path = os.path.join(full_path, item)
+            if os.path.isdir(item_path):
+                directories.append(f"📁 {item}/")
+            else:
+                size = os.path.getsize(item_path)
+                files.append(f"📄 {item} ({size} bytes)")
+        
+        result = f"Contents of '{path}':\n\n"
+        if directories:
+            result += "Directories:\n" + "\n".join(directories) + "\n\n"
+        if files:
+            result += "Files:\n" + "\n".join(files)
+        
+        return result
+        
+    except PermissionError:
+        return f"Error: Permission denied listing directory '{path}'."
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Error listing directory '{path}': {str(e)}\n{tb_str}"
+
 
 @tool
 def audio_transcription_tool(file_path: str) -> str:
-    """Transcribes an audio file (like .mp3 or .wav) and returns the text content."""
-    if not isinstance(file_path, str) or not file_path.strip(): return "Error: Invalid input. 'file_path' must be a non-empty string."
+    """Transcribes an audio file (mp3, wav, etc.) to text using Whisper."""
+    if not isinstance(file_path, str) or not file_path.strip():
+        return "Error: Invalid input. 'file_path' must be a non-empty string."
+    
     print(f"--- Calling Audio Transcription: {file_path} ---")
-    if asr_pipeline is None: return "Error: ASR pipeline unavailable."
+    
+    if asr_pipeline is None:
+        return "Error: ASR pipeline is not available. Audio transcription cannot be performed."
+    
     try:
-        # (Keep your existing path finding logic for audio files)
-        script_dir = os.getcwd(); full_path = os.path.join(script_dir, file_path)
-        if not os.path.exists(full_path):
-             full_path = file_path
-             if not os.path.exists(full_path):
-                  base_path = os.path.basename(file_path)
-                  cwd_base_path = os.path.join(os.getcwd(), base_path)
-                  if os.path.exists(cwd_base_path): full_path = cwd_base_path
-                  else: return f"Error: Audio file not found." # More specific error
+        # Find file using same strategy as read_file
+        script_dir = os.getcwd()
+        safe_path = os.path.normpath(file_path)
+        
+        paths_to_try = [
+            os.path.join(script_dir, safe_path),
+            safe_path,
+            os.path.join(os.getcwd(), os.path.basename(safe_path))
+        ]
+        
+        full_path = None
+        for attempt_path in paths_to_try:
+            if os.path.exists(attempt_path):
+                full_path = attempt_path
+                break
+        
+        if not full_path:
+            return f"Error: Audio file not found: '{file_path}'"
+        
         print(f"Transcribing file: {full_path}")
         transcription = asr_pipeline(full_path)
         result_text = transcription.get("text", "")
-        if not result_text: return "Error: Transcription failed or produced empty text."
-        return result_text
-    except Exception as e: tb_str = traceback.format_exc(); return f"Error transcribing '{file_path}': {str(e)}\nTraceback:\n{tb_str}"
+        
+        if not result_text:
+            return "Error: Transcription produced no text. The audio file may be empty or corrupted."
+        
+        # Truncate if too long
+        if len(result_text) > MAX_MESSAGE_LENGTH:
+            result_text = result_text[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, original length unknown]"
+        
+        return f"Transcription:\n{result_text}"
+        
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Error transcribing '{file_path}': {str(e)}\n{tb_str}"
+
 
 @tool
 def get_youtube_transcript(video_url: str) -> str:
-    """Fetches YouTube transcript for the given video URL."""
-    if not isinstance(video_url, str) or not video_url.strip(): return "Error: Invalid input. 'video_url' must be a non-empty string."
+    """Fetches the transcript/captions for a YouTube video."""
+    if not isinstance(video_url, str) or not video_url.strip():
+        return "Error: Invalid input. 'video_url' must be a non-empty string."
+    
     print(f"--- Calling YouTube Transcript: {video_url} ---")
+    
     try:
+        # Extract video ID
         video_id = None
-        if "watch?v=" in video_url: video_id = video_url.split("v=")[1].split("&")[0]
-        elif "youtu.be/" in video_url: video_id = video_url.split("youtu.be/")[1].split("?")[0]
-        if not video_id: return f"Error: Could not extract YouTube video ID from URL '{video_url}'."
+        if "watch?v=" in video_url:
+            video_id = video_url.split("v=")[1].split("&")[0]
+        elif "youtu.be/" in video_url:
+            video_id = video_url.split("youtu.be/")[1].split("?")[0]
+        elif len(video_url) == 11 and video_url.isalnum():  # Direct video ID
+            video_id = video_url
+        
+        if not video_id:
+            return f"Error: Could not extract YouTube video ID from '{video_url}'. Provide a valid YouTube URL."
+        
+        print(f"Fetching transcript for video ID: {video_id}")
         transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
-        if not transcript_list: return "Error: No transcript found for this video."
+        
+        if not transcript_list:
+            return "Error: No transcript found for this video. It may not have captions available."
+        
         full_transcript = " ".join([item["text"] for item in transcript_list])
-        return full_transcript[:8000] # Keep length limit
-    except Exception as e: tb_str = traceback.format_exc(); return f"Error getting transcript for '{video_url}': {str(e)}\nTraceback:\n{tb_str}"
+        
+        # Truncate if too long
+        if len(full_transcript) > MAX_MESSAGE_LENGTH:
+            full_transcript = full_transcript[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(full_transcript)} total chars]"
+        
+        return f"YouTube Transcript:\n{full_transcript}"
+        
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Error getting transcript for '{video_url}': {str(e)}\nThis video may not have transcripts available.\n{tb_str}"
+
 
 @tool
 def scrape_web_page(url: str) -> str:
-    """Fetches primary text content of a webpage specified by URL."""
-    if not isinstance(url, str) or not url.strip(): return "Error: Invalid input. 'url' must be a non-empty string."
-    # Basic URL scheme check
-    if not url.lower().startswith(('http://', 'https://')): return f"Error: Invalid URL scheme. URL must start with http:// or https://. Received: '{url}'"
+    """Fetches and extracts the main text content from a webpage."""
+    if not isinstance(url, str) or not url.strip():
+        return "Error: Invalid input. 'url' must be a non-empty string."
+    
+    if not url.lower().startswith(('http://', 'https://')):
+        return f"Error: Invalid URL. Must start with http:// or https://. Got: '{url}'"
+    
     print(f"--- Calling Web Scraper: {url} ---")
+    
     try:
-        headers = {'User-Agent': 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)'} # Be a good bot
-        response = requests.get(url, headers=headers, timeout=20); response.raise_for_status()
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=20)
+        response.raise_for_status()
+        
         content_type = response.headers.get('Content-Type', '').lower()
-        if 'html' not in content_type: return f"Error: Content type is '{content_type}', not HTML."
+        if 'html' not in content_type:
+            return f"Error: URL returned '{content_type}', not HTML. Cannot scrape non-HTML content."
+        
         soup = BeautifulSoup(response.text, 'html.parser')
-        # (Keep your existing tag extraction logic)
-        for tag in soup(["script", "style", "nav", "footer", "aside", "header", "form", "button", "input", "img", "link", "meta"]): tag.extract()
-        main_content = soup.find('main') or soup.find('article') or soup.find('div', role='main') or soup.body
-        if not main_content: return "Error: Could not find main body content."
+        
+        # Remove unwanted elements
+        for tag in soup(["script", "style", "nav", "footer", "aside", "header", 
+                        "form", "button", "input", "img", "link", "meta"]):
+            tag.extract()
+        
+        # Try to find main content area
+        main_content = (soup.find('main') or 
+                       soup.find('article') or 
+                       soup.find('div', role='main') or 
+                       soup.find('div', class_=lambda x: x and 'content' in x.lower()) or
+                       soup.body)
+        
+        if not main_content:
+            return "Error: Could not find main content area on the page."
+        
         text = main_content.get_text(separator='\n', strip=True)
-        lines = (line.strip() for line in text.splitlines()); chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+        
+        # Clean up whitespace
+        lines = (line.strip() for line in text.splitlines())
+        chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
         text = '\n'.join(chunk for chunk in chunks if chunk)
-        if not text: return "Error: Scraped content was empty after cleaning."
-        return text[:8000] # Keep length limit
+        
+        if not text:
+            return "Error: Scraped content was empty after cleaning."
+        
+        # Truncate if too long
+        if len(text) > MAX_MESSAGE_LENGTH:
+            text = text[:MAX_MESSAGE_LENGTH] + f"\n...[truncated, {len(text)} total chars]"
+        
+        return f"Content from {url}:\n\n{text}"
+        
+    except requests.exceptions.Timeout:
+        return f"Error: Request to {url} timed out after 20 seconds."
     except requests.exceptions.RequestException as req_e:
         return f"Error fetching URL {url}: {str(req_e)}"
-    except Exception as e: tb_str = traceback.format_exc(); return f"Error scraping {url}: {str(e)}\nTraceback:\n{tb_str}"
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        return f"Error scraping {url}: {str(e)}\n{tb_str}"
 
 
 @tool
 def final_answer_tool(answer: str) -> str:
     """
     Call this tool ONLY when you have the final, definitive answer.
-    The 'answer' argument must be a string containing only the concise, factual answer.
+    The 'answer' must be EXACTLY what was asked for, with no extra text.
+    Examples:
+    - If asked for a number: "42" (not "The answer is 42")
+    - If asked for a list: "apple, banana, cherry"
+    - If asked for a name: "John Smith"
     """
-    # --- Input Validation ---
     if not isinstance(answer, str):
-        # Attempt conversion, or return error if not possible/sensible
-        try: answer = str(answer)
-        except: return "Error: Invalid input. 'answer' must be a string or convertible to a string."
-    # --- End Validation ---
-    print(f"--- AGENT CALLING FINAL ANSWER TOOL ---")
-    return answer # The tool itself just returns the answer
-
-# --- Helper Function for Cleaning Fences (Keep as is) ---
+        try:
+            answer = str(answer)
+        except:
+            return "Error: Invalid input. 'answer' must be a string."
+    
+    print(f"--- FINAL ANSWER TOOL CALLED ---")
+    print(f"Answer: {answer}")
+    return answer
+
+
+# --- Helper Function ---
 def remove_fences_simple(text):
-    original_text = text; text = text.strip()
+    """Remove code fences from text."""
+    original_text = text
+    text = text.strip()
+    
     if text.startswith("```") and text.endswith("```"):
         text = text[3:-3].strip()
         if '\n' in text:
             first_line, rest = text.split('\n', 1)
+            # Remove language identifier
             if first_line.strip().replace('_','').isalnum() and len(first_line.strip()) < 15:
                 text = rest.strip()
         return text
+    
     return original_text
 
-# List of standalone tool functions
+
+# List of all tools
 defined_tools = [
     search_tool,
     code_interpreter,
@@ -294,195 +485,238 @@ defined_tools = [
     get_youtube_transcript,
     scrape_web_page,
     final_answer_tool
-] # Ensure remove_fences_simple is NOT here
+]
+
 
 # --- LangGraph Agent State ---
 class AgentState(TypedDict):
     messages: Annotated[List[AnyMessage], add_messages]
-    turn: int # <-- Added turn counter
+    turn: int
 
-# --- Custom Conditional Edge ---
+
+# --- Conditional Edge Function ---
 def should_continue(state: AgentState):
-    """
-    Custom logic: loop for thoughts, route to tools, end on final_answer or limit.
-    """
+    """Decide whether to continue, call tools, or end."""
     last_message = state['messages'][-1]
     current_turn = state.get('turn', 0)
 
-    # 1. Check for explicit end signal (final_answer_tool)
+    # 1. Check for final_answer_tool
     if isinstance(last_message, AIMessage) and last_message.tool_calls:
-        if last_message.tool_calls[0].get("name") == "final_answer_tool":
-            print("--- Condition: Saw final_answer_tool, ending graph. ---")
-            return END
+        for tool_call in last_message.tool_calls:
+            if tool_call.get("name") == "final_answer_tool":
+                print("--- Condition: final_answer_tool called, ending. ---")
+                return END
 
-    # 2. Check turn limit *before* deciding to loop or call tools
+    # 2. Check turn limit
     if current_turn >= MAX_TURNS:
-        print(f"--- Condition: Reached max turns ({MAX_TURNS}). Forcing END. ---")
-        # Optional: Append an error message for clarity in final output
-        state['messages'].append(SystemMessage(content=f"SYSTEM: Agent reached maximum turn limit ({MAX_TURNS}). Ending execution."))
+        print(f"--- Condition: Max turns ({MAX_TURNS}) reached. Ending. ---")
+        state['messages'].append(
+            SystemMessage(content=f"SYSTEM: Maximum turn limit ({MAX_TURNS}) reached. Ending execution.")
+        )
         return END
 
-    # 3. If tools were called (and it wasn't final_answer), route to tools node
+    # 3. Route to tools if tool calls exist
     if isinstance(last_message, AIMessage) and last_message.tool_calls:
-        print("--- Condition: Saw other tools, calling tools node. ---")
+        print("--- Condition: Tools called, routing to tools node. ---")
         return "tools"
 
-    # 4. If no tool call and not over limit, loop back to agent (reasoning loop)
-    print(f"--- Condition: No tool call (Turn {current_turn}). Looping back to agent. ---")
+    # 4. Loop back to agent (reasoning/planning step)
+    print(f"--- Condition: No tool call (Turn {current_turn}). Continuing to agent. ---")
     return "agent"
 
-# --- Basic Agent Definition ---
+
+# ====================================================
+# --- Basic Agent Class ---
 class BasicAgent:
     def __init__(self):
         print("BasicAgent (LangGraph) initializing...")
+        
         GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-        if not GROQ_API_KEY: raise ValueError("GROQ_API_KEY secret is not set!")
+        if not GROQ_API_KEY:
+            raise ValueError("GROQ_API_KEY environment variable is not set!")
 
         self.tools = defined_tools
         
-        # Build tool descriptions separately to avoid f-string backslash issues
+        # Build tool descriptions
         tool_desc_list = []
         for tool in self.tools:
             if tool.name == 'code_interpreter':
-                desc = (f"- {tool.name}: Executes Python code. Use for calculations, data manipulation, or logic puzzles.\n"
-                        f"  **CODE INTERPRETER RULES:**\n"
-                        f"  1. ALWAYS use `print()` for final results.\n"
-                        f"  2. Write SIMPLE, single-step scripts.\n"
-                        f"  3. PLAN your next script using plain text output first.\n"
-                        f"  4. Write reasoning as Python comments (#) before code.\n"
-                        f"  'pandas' (as pd) is available.")
+                desc = (
+                    f"- {tool.name}: Executes Python code. Use for calculations, data analysis, logic puzzles.\n"
+                    f"  **CRITICAL RULES:**\n"
+                    f"  1. ALWAYS use print() to output results\n"
+                    f"  2. Write simple, focused code (one task per execution)\n"
+                    f"  3. Add comments (#) to explain your logic\n"
+                    f"  Available: pandas as pd"
+                )
             else:
                 desc = f"- {tool.name}: {tool.description}"
             tool_desc_list.append(desc)
         
         tool_descriptions = "\n".join(tool_desc_list)
 
-        # ==================== SYSTEM PROMPT V5 (Improved) ====================
-        self.system_prompt = f"""You are a highly intelligent and meticulous AI assistant for the GAIA benchmark.
-Your goal is to provide the EXACT, concise, factual answer by strictly following a step-by-step reasoning process.
+        # ==================== SYSTEM PROMPT V5 ====================
+        self.system_prompt = f"""You are a highly intelligent AI assistant for the GAIA benchmark.
+Your goal: Provide the EXACT answer in the EXACT format requested.
 
-**CRITICAL PROTOCOL: YOU MUST FOLLOW THIS PROCESS**
+**PROTOCOL:**
 
-1.  **ANALYZE:** Read the question carefully. Identify what format the answer should be in (number, yes/no, list, name, etc.).
-2.  **PLAN (First Turn Only):** Your *first* response MUST be a brief plan in plain text:
-    - What information do you need?
-    - Which tool will you use first?
-    - What format should the final answer be in?
-    DO NOT call any tool on your first turn.
-    
-3.  **EXECUTE ONE TOOL:** Call exactly ONE tool per turn. Wait for the result before planning your next step.
+1. **ANALYZE QUESTION:**
+   - What information is needed?
+   - What format should the answer be? (number, list, yes/no, name, etc.)
+   - Are there any files attached?
+
+2. **FIRST TURN - MAKE A PLAN:**
+   Your FIRST response MUST be a brief plan (2-3 sentences):
+   - What tools you'll use
+   - What order you'll use them
+   - What format the final answer should be
+   DO NOT call tools on your first turn!
+
+3. **EXECUTE:**
+   - Call ONE tool per turn
+   - Wait for the result before planning your next step
+   - For ANY calculation or logic: use code_interpreter with print()
+
+4. **VERIFY RESULTS:**
+   - Check if tool output contains errors
+   - If error: plan a different approach
+   - If success: decide if you need more info or have the answer
+
+5. **FINISH:**
+   When you have the answer from a tool output:
+   - Call final_answer_tool immediately
+   - Provide ONLY the exact answer (no explanations!)
 
-4.  **VERIFY TOOL OUTPUT:** 
-    - Read the ToolMessage carefully
-    - Check if it contains errors - if so, plan a different approach
-    - Check if you have enough information for the final answer
-    
-5.  **ITERATE OR FINISH:**
-    - **Need more info?** Write a brief plan (1-2 sentences) then call the next tool
-    - **Have the answer?** Call `final_answer_tool` immediately with the EXACT answer from the tool output
-    
 **CRITICAL RULES:**
 
-* **ANSWER FORMAT:** Match the exact format requested (if question asks for a number, return ONLY the number; if it asks for a list, return ONLY the list)
-* **NO HALLUCINATIONS:** The answer MUST come from tool outputs, NEVER from your training data
-* **ONE TOOL PER TURN:** Never call multiple tools or make plans and tool calls in the same turn
-* **USE CODE FOR LOGIC:** For ANY calculation, counting, or logical reasoning, use `code_interpreter` and ensure it prints the result
-* **ERROR RECOVERY:** If a tool fails, analyze WHY and try a completely different approach
-* **FINAL ANSWER FORMAT:** Strip ALL explanatory text. Examples:
-  - Question asks for number → Answer: "42" (not "The answer is 42" or "42 coins")
-  - Question asks for list → Answer: "apple, banana, cherry" (not "The list is: apple, banana, cherry")
-  - Question asks for yes/no → Answer: "Yes" or "No" (not "Yes, because...")
+❌ NEVER guess or use training data for the final answer
+❌ NEVER call multiple tools in one turn
+❌ NEVER add explanations to final_answer_tool
+✅ ALWAYS use code_interpreter for calculations/logic
+✅ ALWAYS match the requested answer format exactly
+✅ ALWAYS base your answer on tool outputs, not memory
+
+**ANSWER FORMAT EXAMPLES:**
+- "What is 5+5?" → final_answer("10")
+- "List the colors" → final_answer("red, blue, green")
+- "Is it true?" → final_answer("Yes") or final_answer("No")
+- "What's the name?" → final_answer("John Smith")
 
 **TOOLS:**
 {tool_descriptions}
 
-**REMEMBER:** 
-- Use tools, don't guess
-- One tool at a time
-- Final answer must match requested format exactly
-- No explanations in final answer
+**REMEMBER:** One tool per turn. Base everything on tool outputs. Match the format exactly.
 """
 
-        print("Initializing Groq LLM Endpoint...")
+        print("Initializing Groq LLM...")
         try:
             chat_llm = ChatGroq(
-                temperature=0, # Changed from 0.01 to 0 for maximum determinism
+                temperature=0,  # Maximum determinism
                 groq_api_key=GROQ_API_KEY,
-                model_name="llama-3.3-70b-versatile", # Better model for reasoning
-                max_tokens=4096, # Explicit limit
-                timeout=60 # Add timeout for stability
+                model_name="llama-3.3-70b-versatile",  # Best reasoning model
+                max_tokens=4096,
+                timeout=60
             )
-            print("✅ Groq LLM Endpoint initialized with llama-3.3-70b-versatile.")
-        except Exception as e: 
-            print(f"Error initializing Groq: {e}")
+            print("✅ Groq LLM initialized with llama-3.3-70b-versatile")
+        except Exception as e:
+            print(f"❌ Error initializing Groq: {e}")
             raise
         
         self.llm_with_tools = chat_llm.bind_tools(self.tools)
-        print("✅ Tools bound to LLM (using bind_tools).")
- 
-    # --- Agent Node with Robust Parsing Fallback ---
-    def agent_node(state: AgentState):
-        current_turn = state.get('turn', 0) + 1
-        print(f"--- Running Agent Node (Turn {current_turn}) ---")
-        
-        # Ensure message history isn't excessively long (optional safety)
-        # if len(state['messages']) > 20: 
-        #     print("Warning: Pruning message history to prevent excessive length.")
-        #     messages_to_send = [state['messages'][0]] + state['messages'][-19:] # Keep system + last N
-        # else:
-        #     messages_to_send = state["messages"]
-        messages_to_send = state["messages"] # Keep all for now
-        ai_message: AIMessage = self.llm_with_tools.invoke(messages_to_send)
-        # --- Robust Parsing Fallback ---
-        if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
-            # Simple JSON block finder (might need refinement for complex cases)
-            json_match = re.search(r"```(?:json)?\s*(\{.*?\})\s*```|(\{.*?\})", ai_message.content, re.DOTALL | re.IGNORECASE)
-            if json_match:
-                json_str = json_match.group(1) or json_match.group(2)
+        print("✅ Tools bound to LLM")
+        
+        # --- Agent Node ---
+        def agent_node(state: AgentState):
+            current_turn = state.get('turn', 0) + 1
+            print(f"\n{'='*60}")
+            print(f"AGENT TURN {current_turn}/{MAX_TURNS}")
+            print('='*60)
+            
+            messages_to_send = state["messages"]
+            
+            # Retry logic with exponential backoff
+            max_retries = 3
+            ai_message = None
+            
+            for attempt in range(max_retries):
                 try:
-                    parsed_json = json.loads(json_str)
-                    # Basic validation for *our* tool format
-                    if isinstance(parsed_json, dict) and "tool" in parsed_json and "tool_input" in parsed_json:
-                        tool_name = parsed_json.get("tool")
-                        tool_input = parsed_json.get("tool_input", {})
-                        # Check if the tool name is actually one we defined
-                        if any(t.name == tool_name for t in self.tools):
-                            print(f"--- Fallback: Manually parsed tool call for '{tool_name}' from content ---")
-                            tool_call = ToolCall(name=tool_name, args=tool_input, id=str(uuid.uuid4()))
-                            ai_message.tool_calls = [tool_call]
-                            ai_message.content = "" # Clear content as it's parsed
-                        else:
-                            print(f"--- Fallback Warning: Found JSON, but tool '{tool_name}' is not defined. ---")
-                    else:
-                         print("--- Fallback Warning: Found JSON, but not in expected tool format {tool:..., tool_input:...}. ---")
-                except json.JSONDecodeError as json_err:
-                    print(f"--- Fallback Warning: Found text resembling JSON, but failed to parse: {json_err} ---")
-        # --- End Fallback ---
-        print(f"AI Message Raw Content: {ai_message.content}")
-        if ai_message.tool_calls: print(f"AI tool calls: {ai_message.tool_calls}")
-        elif ai_message.invalid_tool_calls: print(f"AI INVALID tool calls: {ai_message.invalid_tool_calls}")
-        else: print(f"AI content (no calls): {ai_message.pretty_repr()}")
-        return {"messages": [ai_message], "turn": current_turn}
-    tool_node = ToolNode(self.tools)
-    print("Building agent graph...")
-    graph_builder = StateGraph(AgentState)
-    graph_builder.add_node("agent", agent_node)
-    graph_builder.add_node("tools", tool_node)
-    graph_builder.add_edge(START, "agent")
-    graph_builder.add_edge("tools", "agent") # Always go back to agent after tools
-    # --- Updated Conditional Edges ---
-    graph_builder.add_conditional_edges(
-        "agent",
-        should_continue,
-        {
-            "tools": "tools",  # If tools are called (and not final_answer)
-            "agent": "agent",  # If text/plan is generated (reasoning loop)
-            END: END           # If final_answer called or turn limit reached
-        }
-    )
-    self.graph = graph_builder.compile()
-    print("✅ Graph compiled.")
-# --- __call__ Method (Keep mostly as is, just init turn) ---
+                    ai_message = self.llm_with_tools.invoke(messages_to_send)
+                    break
+                except Exception as e:
+                    print(f"⚠️ LLM attempt {attempt+1}/{max_retries} failed: {e}")
+                    if attempt == max_retries - 1:
+                        error_msg = AIMessage(
+                            content=f"Error: LLM failed after {max_retries} attempts: {str(e)}"
+                        )
+                        return {"messages": [error_msg], "turn": current_turn}
+                    time.sleep(2 ** attempt)  # Exponential backoff
+            
+            # --- Fallback JSON parsing ---
+            if not ai_message.tool_calls and isinstance(ai_message.content, str) and ai_message.content.strip():
+                json_match = re.search(
+                    r"```(?:json)?\s*(\{.*?\})\s*```|(\{.*?\})", 
+                    ai_message.content, 
+                    re.DOTALL | re.IGNORECASE
+                )
+                
+                if json_match:
+                    json_str = json_match.group(1) or json_match.group(2)
+                    try:
+                        parsed_json = json.loads(json_str)
+                        if isinstance(parsed_json, dict) and "tool" in parsed_json and "tool_input" in parsed_json:
+                            tool_name = parsed_json.get("tool")
+                            tool_input = parsed_json.get("tool_input", {})
+                            
+                            if any(t.name == tool_name for t in self.tools):
+                                print(f"🔧 Fallback: Parsed tool call for '{tool_name}' from JSON in content")
+                                tool_call = ToolCall(
+                                    name=tool_name, 
+                                    args=tool_input, 
+                                    id=str(uuid.uuid4())
+                                )
+                                ai_message.tool_calls = [tool_call]
+                                ai_message.content = ""
+                    except json.JSONDecodeError:
+                        pass
+            
+            # --- Logging ---
+            if ai_message.tool_calls:
+                for tc in ai_message.tool_calls:
+                    print(f"🔧 Tool Call: {tc.get('name')}")
+                    print(f"   Args: {tc.get('args', {})}")
+            elif ai_message.content:
+                content_preview = ai_message.content[:300]
+                if len(ai_message.content) > 300:
+                    content_preview += "..."
+                print(f"💭 Agent Reasoning:\n{content_preview}")
+            
+            return {"messages": [ai_message], "turn": current_turn}
+        
+        # --- Tool Node ---
+        tool_node = ToolNode(self.tools)
+        
+        # --- Build Graph ---
+        print("Building agent graph...")
+        graph_builder = StateGraph(AgentState)
+        graph_builder.add_node("agent", agent_node)
+        graph_builder.add_node("tools", tool_node)
+        
+        graph_builder.add_edge(START, "agent")
+        graph_builder.add_edge("tools", "agent")
+        
+        graph_builder.add_conditional_edges(
+            "agent",
+            should_continue,
+            {
+                "tools": "tools",
+                "agent": "agent",
+                END: END
+            }
+        )
+        
+        self.graph = graph_builder.compile()
+        print("✅ Graph compiled successfully")
 def __call__(self, question: str) -> str:
     print(f"\n--- Starting Agent Run for Question ---")
     print(f"Agent received question (first 100 chars): {question[:100]}...")