Update app.py

app.py

@@ -1,5 +1,8 @@
 import os
 import re
+import io
+import json
+import traceback
 import gradio as gr
 import requests
 import pandas as pd
@@ -9,9 +12,15 @@ from smolagents import CodeAgent, DuckDuckGoSearchTool, InferenceClientModel, to
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Modello gratuito che funziona senza token Pro
-MAIN_MODEL    = "Qwen/Qwen2.5-Coder-32B-Instruct"
-FALLBACK_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
+# Modelli in ordine di preferenza (tutti gratuiti su HF Inference API)
+MODEL_CANDIDATES = [
+    "Qwen/Qwen2.5-Coder-32B-Instruct",
+    "Qwen/Qwen2.5-72B-Instruct",
+    "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "mistralai/Mixtral-8x7B-Instruct-v0.1",
+    "HuggingFaceH4/zephyr-7b-beta",
+]
+
 
 # ==========================================
 # 🔧 TOOL 1: LETTURA WEBPAGE
@@ -24,15 +33,20 @@ def visit_webpage(url: str) -> str:
         url: The full URL of the webpage to visit.
     """
     try:
-        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
-        response = requests.get(url, headers=headers, timeout=15)
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+        response = requests.get(url, headers=headers, timeout=20)
         response.raise_for_status()
-        soup = BeautifulSoup(response.text, 'html.parser')
-        for el in soup(["script", "style", "nav", "footer", "header", "aside"]):
+        soup = BeautifulSoup(response.text, "html.parser")
+        for el in soup(["script", "style", "nav", "footer", "header", "aside", "noscript"]):
             el.extract()
-        return soup.get_text(separator='\n', strip=True)[:15000]
+        text = soup.get_text(separator="\n", strip=True)
+        # Pulizia extra
+        lines = [l.strip() for l in text.splitlines() if l.strip()]
+        return "\n".join(lines)[:15000]
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error fetching {url}: {str(e)}"
 
 
 # ==========================================
@@ -43,56 +57,135 @@ def get_youtube_transcript(video_url: str) -> str:
     """Fetches the transcript/captions of a YouTube video.
     Use this whenever the question refers to a YouTube video URL.
     Args:
-        video_url: The full YouTube video URL.
+        video_url: The full YouTube video URL (or just the video ID).
     """
     try:
         from youtube_transcript_api import YouTubeTranscriptApi
-        match = re.search(r'(?:v=|youtu\.be/)([^&\n?#]+)', video_url)
-        if not match:
-            return "Could not extract video ID from URL."
-        video_id = match.group(1)
-        entries = YouTubeTranscriptApi.get_transcript(video_id, languages=['en', 'it', 'auto'])
-        return ' '.join([e['text'] for e in entries])[:10000]
+
+        match = re.search(r"(?:v=|youtu\.be/|embed/)([^&\n?#]+)", video_url)
+        video_id = match.group(1) if match else video_url.strip()
+
+        try:
+            entries = YouTubeTranscriptApi.get_transcript(video_id, languages=["en"])
+        except Exception:
+            try:
+                entries = YouTubeTranscriptApi.get_transcript(video_id)
+            except Exception:
+                transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+                transcript = transcript_list.find_generated_transcript(["en", "it", "fr", "de", "es"])
+                entries = transcript.fetch()
+
+        full = " ".join([e["text"] for e in entries])
+        return full[:12000]
     except Exception as e:
-        return f"Transcript not available: {str(e)}"
+        return f"Transcript error: {str(e)}"
 
 
 # ==========================================
-# 📂 TOOL 3: DOWNLOAD FILE DA GAIA
+# 📂 TOOL 3: DOWNLOAD + PARSE FILE DA GAIA
 # ==========================================
 @tool
 def download_task_file(task_id: str) -> str:
-    """Downloads and reads the file attached to a GAIA task (if any).
+    """Downloads and reads the file attached to a GAIA task.
+    Handles text, CSV, JSON, PDF, Excel (.xlsx/.xls), Python, and audio files.
     Always try this if the question might reference an attached document, table, or file.
     Args:
         task_id: The task_id string from the GAIA question.
     """
     try:
         file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-        response = requests.get(file_url, timeout=15)
+        response = requests.get(file_url, timeout=30)
         if response.status_code == 404:
             return "No file attached to this task."
         response.raise_for_status()
-        content_type = response.headers.get('Content-Type', '')
-
-        if any(t in content_type for t in ['text', 'json', 'csv']):
-            return response.text[:10000]
-
-        if 'pdf' in content_type:
+        ct = response.headers.get("Content-Type", "")
+        cd = response.headers.get("Content-Disposition", "")
+
+        # Detect filename from Content-Disposition
+        filename = ""
+        if "filename=" in cd:
+            filename = cd.split("filename=")[-1].strip('" ')
+        ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+
+        print(f"  [FILE] type={ct}, name={filename}, ext={ext}, size={len(response.content)}")
+
+        # --- TEXT / CSV / JSON ---
+        if any(t in ct for t in ["text", "json", "csv"]) or ext in ["txt", "csv", "json", "py", "md"]:
+            text = response.text
+            if ext == "csv" or "csv" in ct:
+                try:
+                    df = pd.read_csv(io.StringIO(text))
+                    return f"CSV file with {len(df)} rows, columns: {list(df.columns)}\n\n{df.to_string()}"[:12000]
+                except Exception:
+                    pass
+            return text[:12000]
+
+        # --- EXCEL ---
+        if "spreadsheet" in ct or "excel" in ct or ext in ["xlsx", "xls"]:
+            try:
+                df = pd.read_excel(io.BytesIO(response.content), engine="openpyxl")
+                summary = f"Excel file with {len(df)} rows, columns: {list(df.columns)}\n"
+                summary += f"Data types: {dict(df.dtypes)}\n\n"
+                summary += df.to_string()
+                return summary[:12000]
+            except Exception as e:
+                return f"Excel file but read error: {e}"
+
+        # --- PDF ---
+        if "pdf" in ct or ext == "pdf":
             try:
-                import io, PyPDF2
+                import PyPDF2
                 reader = PyPDF2.PdfReader(io.BytesIO(response.content))
-                return ''.join([p.extract_text() or '' for p in reader.pages])[:10000]
-            except Exception:
-                return f"PDF attached but could not extract text."
-
-        if 'image' in content_type:
-            return f"Image file attached ({content_type})."
-
+                pages_text = []
+                for i, page in enumerate(reader.pages):
+                    t = page.extract_text() or ""
+                    pages_text.append(f"[Page {i+1}]\n{t}")
+                return "\n".join(pages_text)[:12000]
+            except Exception as e:
+                return f"PDF attached but read error: {e}"
+
+        # --- AUDIO (mp3, wav) ---
+        if "audio" in ct or ext in ["mp3", "wav", "m4a", "ogg"]:
+            return f"Audio file attached ({ct}, {len(response.content)} bytes). Cannot transcribe directly."
+
+        # --- IMAGE ---
+        if "image" in ct or ext in ["png", "jpg", "jpeg", "gif", "webp"]:
+            return f"Image file attached ({ct}, {len(response.content)} bytes)."
+
+        # --- Fallback: try decode as text ---
         try:
-            return response.content.decode('utf-8')[:10000]
+            decoded = response.content.decode("utf-8")
+            return decoded[:12000]
         except Exception:
-            return f"Binary file attached ({content_type})."
+            return f"Binary file ({ct}, {len(response.content)} bytes). Cannot parse."
+
+    except Exception as e:
+        return f"File download error: {str(e)}"
+
+
+# ==========================================
+# 🧮 TOOL 4: PYTHON EVAL SICURO
+# ==========================================
+@tool
+def python_compute(code: str) -> str:
+    """Executes a Python expression or short script and returns the result.
+    Use for math calculations, string manipulation, date computations, etc.
+    Args:
+        code: A Python expression or short script. Use print() for output.
+    """
+    try:
+        # Prova prima come espressione
+        result = eval(code)
+        return str(result)
+    except SyntaxError:
+        # Se è uno statement, eseguilo e cattura stdout
+        import contextlib
+        import sys
+        f = io.StringIO()
+        with contextlib.redirect_stdout(f):
+            exec(code)
+        output = f.getvalue().strip()
+        return output if output else "Code executed (no output)"
     except Exception as e:
         return f"Error: {str(e)}"
 
@@ -101,34 +194,41 @@ def download_task_file(task_id: str) -> str:
 # 🔍 PRE-PROCESSING
 # ==========================================
 def preprocess_question(question: str) -> str:
+    """Detect reversed text and fix it."""
     stripped = question.strip()
-    reversed_q = stripped[::-1].strip()
-    keywords = ['answer', 'write', 'what', 'who', 'how', 'find', 'list', 'if you', 'understand']
-    if len(reversed_q) > 15:
-        has_keywords_reversed = any(w in reversed_q.lower() for w in keywords)
-        has_keywords_original = any(w in stripped.lower() for w in keywords)
-        if has_keywords_reversed and not has_keywords_original:
-            print(f"[PRE-PROCESS] Testo invertito → {reversed_q[:80]}")
-            return reversed_q
+    reversed_q = stripped[::-1]
+
+    keywords_en = ["answer", "what", "who", "how", "find", "list", "which", "where", "when", "the"]
+    keywords_present_original = sum(1 for w in keywords_en if w in stripped.lower())
+    keywords_present_reversed = sum(1 for w in keywords_en if w in reversed_q.lower())
+
+    if keywords_present_reversed > keywords_present_original and len(stripped) > 20:
+        print(f"  [PRE-PROCESS] Reversed text detected! Using reversed version.")
+        return reversed_q
+
     return question
 
 
 # ==========================================
-# 🤖 FALLBACK DIRETTO VIA HF API
+# 🔄 CHIAMATA DIRETTA HF INFERENCE API
 # ==========================================
-def call_hf_direct(question: str) -> str:
-    """
-    Chiama l'API HF Serverless Inference direttamente via requests.
-    Non dipende da smolagents né da huggingface_hub — funziona sempre.
-    """
-    prompt = f"""Answer the following question with ONLY the final answer.
-No explanation. No preamble. Just the bare answer.
-- Numbers only for numeric answers.
-- Single word/name for name answers.  
-- If the text seems reversed/backwards, reverse it first then answer.
-- No punctuation at the end.
+def call_hf_direct(question: str, task_context: str = "") -> str:
+    """Fallback: chiama HF Inference API direttamente senza smolagents."""
+
+    prompt = f"""You are answering a question from the GAIA benchmark.
+Give ONLY the final answer — no explanation, no preamble, no "The answer is".
+
+Rules:
+- For numbers: just digits (e.g., 42)
+- For names: just the name (e.g., Einstein)
+- For lists: comma-separated (e.g., apple, banana, cherry)
+- No period at the end unless part of the answer
+- If text seems reversed, reverse it first
+
+{task_context}
 
 Question: {question}
+
 Answer:"""
 
     hf_token = os.getenv("HF_TOKEN", "")
@@ -136,132 +236,302 @@ Answer:"""
     if hf_token:
         headers["Authorization"] = f"Bearer {hf_token}"
 
-    # Prova il modello principale
-    for model in [FALLBACK_MODEL, "mistralai/Mixtral-8x7B-Instruct-v0.1"]:
+    for model in MODEL_CANDIDATES:
         try:
             api_url = f"https://api-inference.huggingface.co/models/{model}"
             payload = {
                 "inputs": prompt,
                 "parameters": {
-                    "max_new_tokens": 100,
+                    "max_new_tokens": 150,
                     "temperature": 0.1,
                     "return_full_text": False,
-                }
+                },
             }
-            resp = requests.post(api_url, headers=headers, json=payload, timeout=30)
-            
+            resp = requests.post(api_url, headers=headers, json=payload, timeout=45)
+
             if resp.status_code == 200:
                 data = resp.json()
                 if isinstance(data, list) and len(data) > 0:
                     raw = data[0].get("generated_text", "").strip()
                     if raw:
-                        print(f"[🔄 FALLBACK HF OK via {model}]: {raw[:80]}")
-                        return clean_answer(raw)
+                        answer = clean_answer(raw)
+                        if answer and answer.lower() not in [
+                            "i don't know", "unknown", "n/a", "none", "error", "",
+                        ]:
+                            print(f"  [FALLBACK OK via {model}]: {answer[:100]}")
+                            return answer
             else:
-                print(f"[FALLBACK {model}] Status {resp.status_code}: {resp.text[:200]}")
+                print(f"  [FALLBACK {model}] HTTP {resp.status_code}")
+
         except Exception as e:
-            print(f"[FALLBACK {model} ERROR]: {e}")
+            print(f"  [FALLBACK {model} ERROR]: {e}")
             continue
 
     return "I don't know"
 
 
+# ==========================================
+# 🧹 PULIZIA RISPOSTA
+# ==========================================
 def clean_answer(raw: str) -> str:
+    """Pulisci la risposta grezza dall'agente."""
     answer = str(raw).strip()
-    # Prendi solo la prima riga se è multilinea
-    first_line = answer.split('\n')[0].strip()
-    if first_line:
-        answer = first_line
 
+    # Se multilinea, prendi la prima riga non vuota significativa
+    lines = [l.strip() for l in answer.split("\n") if l.strip()]
+    if lines:
+        answer = lines[0]
+
+    # Rimuovi prefissi comuni
     prefixes = [
-        "the answer is", "final answer:", "answer:", "final answer is",
-        "the result is", "the word is", "the name is", "the number is",
-        "the correct answer is", "based on", "according to",
+        "the answer is:", "the answer is", "final answer:", "final answer is:",
+        "final answer is", "answer:", "answer is:", "answer is",
+        "the result is:", "the result is", "result:",
+        "the correct answer is:", "the correct answer is",
+        "the word is", "the name is", "the number is",
+        "based on my research,", "based on the information,",
+        "based on the search results,", "according to",
+        "here is the answer:", "sure,", "sure!",
     ]
     lower = answer.lower()
     for prefix in prefixes:
         if lower.startswith(prefix):
             answer = answer[len(prefix):].strip()
             lower = answer.lower()
+            # Rimuovi anche eventuali virgolette dopo il prefisso
+            if answer.startswith('"') or answer.startswith("'"):
+                answer = answer[1:]
             break
 
-    if answer.endswith('.') and not re.search(r'\d\.$', answer):
+    # Rimuovi punto finale (ma non se è un decimale tipo "3.14")
+    if answer.endswith(".") and not re.search(r"\d\.$", answer):
         answer = answer[:-1].strip()
 
-    answer = answer.replace("**", "").strip('"').strip("'").strip()
+    # Rimuovi markdown bold, virgolette
+    answer = answer.replace("**", "").strip('"').strip("'").strip("`").strip()
+
+    # Se la risposta inizia con "is " (residuo), rimuovilo
+    if answer.lower().startswith("is "):
+        answer = answer[3:].strip()
+
     return answer
 
 
 # ==========================================
-# 🧠 IL SUPER AGENTE
+# 🧠 AGENTE PRINCIPALE
 # ==========================================
 class SuperAgent:
     def __init__(self):
-        print("Inizializzazione agente...")
-
-        self.model = InferenceClientModel(model_id=MAIN_MODEL)
-
-        self.tools = [
-            DuckDuckGoSearchTool(),
-            visit_webpage,
-            get_youtube_transcript,
-            download_task_file,
-        ]
-
-        self.agent = CodeAgent(
-            tools=self.tools,
-            model=self.model,
-            max_steps=8,
-            additional_authorized_imports=[
-                "requests", "bs4", "json", "time", "math", "datetime",
-                "pandas", "numpy", "re", "csv", "urllib", "collections",
-                "itertools", "string", "unicodedata"
-            ]
-        )
-
-        self.agent_prompt = """You are an expert AI solving the GAIA benchmark. Find the EXACT correct answer.
+        print("=" * 60)
+        print("🚀 Inizializzazione SuperAgent...")
+        print("=" * 60)
 
-STRATEGY (follow in order):
-1. If question has a YouTube URL → call get_youtube_transcript(url) immediately.
-2. If question has a website URL → call visit_webpage(url).
-3. If question might have an attached file → call download_task_file(task_id).
-4. For factual questions → DuckDuckGoSearchTool, then visit_webpage to confirm.
-5. For math/text/date → write Python to compute directly.
-6. If text looks scrambled/reversed → use Python: text[::-1]
-
-OUTPUT (CRITICAL — follow exactly):
-- Output ONLY the bare answer. Nothing else.
-- Number answers: just the digit(s). Example: 3
-- Name/word answers: just the word. Example: Einstein  
-- List answers: comma-separated. Example: cat, dog, bird
-- NEVER output: "The answer is", "FINAL ANSWER:", "Based on", or any explanation.
+        hf_token = os.getenv("HF_TOKEN", "")
+        print(f"  HF_TOKEN presente: {bool(hf_token)}")
 
+        # Prova a inizializzare il modello per smolagents
+        self.agent = None
+        for model_id in MODEL_CANDIDATES[:3]:  # Prova i primi 3
+            try:
+                print(f"  Trying model: {model_id}")
+                model = InferenceClientModel(
+                    model_id=model_id,
+                    token=hf_token if hf_token else None,
+                )
+
+                self.agent = CodeAgent(
+                    tools=[
+                        DuckDuckGoSearchTool(),
+                        visit_webpage,
+                        get_youtube_transcript,
+                        download_task_file,
+                        python_compute,
+                    ],
+                    model=model,
+                    max_steps=6,
+                    additional_authorized_imports=[
+                        "requests", "bs4", "json", "time", "math", "datetime",
+                        "pandas", "numpy", "re", "csv", "urllib", "collections",
+                        "itertools", "string", "unicodedata", "statistics",
+                    ],
+                )
+                print(f"  ✅ Agent inizializzato con {model_id}")
+                break
+            except Exception as e:
+                print(f"  ❌ {model_id} fallito: {e}")
+                continue
+
+        if self.agent is None:
+            print("  ⚠️ Nessun modello disponibile per l'agente — solo fallback diretto.")
+
+    def _build_prompt(self, question: str, task_id: str, file_context: str = "") -> str:
+        """Costruisci il prompt per l'agente."""
+        file_hint = ""
+        if task_id:
+            file_hint = f'\nThis question has task_id="{task_id}". Call download_task_file("{task_id}") to check for attached files.'
+
+        extra_context = ""
+        if file_context:
+            extra_context = f"\n\nFILE CONTENT:\n{file_context}\n"
+
+        return f"""You are an expert AI assistant solving GAIA benchmark questions.
+Your goal: find the EXACT correct answer.
+
+STRATEGY (follow in this order):
+1. If the question has a YouTube URL → call get_youtube_transcript(url)
+2. If the question has any URL → call visit_webpage(url)
+3. If there might be an attached file → call download_task_file(task_id)
+4. For factual questions → use DuckDuckGoSearchTool, then visit_webpage to verify
+5. For calculations → use python_compute() or write Python directly
+6. If text looks reversed/scrambled → reverse it with Python: text[::-1]
+
+ANSWER FORMAT (CRITICAL):
+- Output ONLY the final answer. No explanation. No prefix.
+- Numbers: just digits (e.g., 3)
+- Names: just the name (e.g., Einstein)
+- Lists: comma-separated (e.g., cat, dog, bird)
+- NEVER say "The answer is..." or "FINAL ANSWER:" or any preamble
+{file_hint}{extra_context}
 Question: {question}"""
 
     def __call__(self, question: str, task_id: str = "") -> str:
-        print(f"\n[Q]: {question[:100]}...")
+        print(f"\n{'─'*60}")
+        print(f"[Q]: {question[:150]}...")
+        print(f"[TASK]: {task_id}")
 
+        # 1. Pre-process (reversed text detection)
         processed = preprocess_question(question)
 
-        context = ""
+        # 2. Se c'è un task_id, prova a scaricare il file subito per avere contesto
+        file_context = ""
         if task_id:
-            context = f"\n(task_id='{task_id}' — use download_task_file('{task_id}') if a file is referenced)\n"
-
-        full_q = processed + context
+            try:
+                fc = download_task_file.__wrapped__(task_id) if hasattr(download_task_file, '__wrapped__') else ""
+                if fc and "No file" not in fc and "error" not in fc.lower():
+                    file_context = fc
+                    print(f"  [FILE PRE-FETCH]: {len(file_context)} chars")
+            except Exception:
+                # Smolagents tool wrapper, proviamo direttamente
+                try:
+                    file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+                    resp = requests.get(file_url, timeout=15)
+                    if resp.status_code == 200:
+                        ct = resp.headers.get("Content-Type", "")
+                        cd = resp.headers.get("Content-Disposition", "")
+                        filename = ""
+                        if "filename=" in cd:
+                            filename = cd.split("filename=")[-1].strip('" ')
+                        ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+
+                        if any(t in ct for t in ["text", "json", "csv"]) or ext in ["txt", "csv", "json", "py"]:
+                            file_context = resp.text[:8000]
+                        elif "spreadsheet" in ct or "excel" in ct or ext in ["xlsx", "xls"]:
+                            try:
+                                df = pd.read_excel(io.BytesIO(resp.content), engine="openpyxl")
+                                file_context = f"Excel: {len(df)} rows, cols={list(df.columns)}\n{df.to_string()}"[:8000]
+                            except Exception:
+                                pass
+                        elif "pdf" in ct or ext == "pdf":
+                            try:
+                                import PyPDF2
+                                reader = PyPDF2.PdfReader(io.BytesIO(resp.content))
+                                file_context = "\n".join(
+                                    [p.extract_text() or "" for p in reader.pages]
+                                )[:8000]
+                            except Exception:
+                                pass
+                        print(f"  [FILE PRE-FETCH direct]: {len(file_context)} chars")
+                except Exception as e:
+                    print(f"  [FILE PRE-FETCH failed]: {e}")
+
+        # 3. Detect special question types and handle directly
+        answer = self._handle_special_cases(processed, task_id, file_context)
+        if answer:
+            print(f"  [SPECIAL CASE]: {answer}")
+            return answer
+
+        # 4. Tentativo con agente smolagents
+        if self.agent:
+            try:
+                prompt = self._build_prompt(processed, task_id, file_context)
+                raw = self.agent.run(prompt)
+                answer = clean_answer(str(raw))
+                if self._is_valid_answer(answer):
+                    print(f"  [✅ AGENT]: {answer}")
+                    return answer
+                print(f"  [⚠️ AGENT invalid: '{answer}']")
+            except Exception as e:
+                print(f"  [⚠️ AGENT ERROR]: {e}")
+                traceback.print_exc()
+
+        # 5. Fallback: HF API diretta
+        print("  [→ FALLBACK HF DIRECT]")
+        context_for_fallback = ""
+        if file_context:
+            context_for_fallback = f"\nAttached file content:\n{file_context[:3000]}\n"
+
+        answer = call_hf_direct(processed, context_for_fallback)
+        print(f"  [FINAL]: {answer}")
+        return answer
+
+    def _is_valid_answer(self, answer: str) -> bool:
+        """Controlla se una risposta è valida (non vuota e non un errore generico)."""
+        if not answer:
+            return False
+        invalid = [
+            "i don't know", "unknown", "n/a", "none", "error",
+            "i cannot", "i can't", "not available", "no answer",
+            "could not", "unable to", "i'm not sure",
+        ]
+        return answer.lower().strip() not in invalid
 
-        # Tentativo 1: agente con tools
-        try:
-            raw = self.agent.run(self.agent_prompt.format(question=full_q))
-            answer = clean_answer(raw)
-            if answer and answer.lower() not in ["error", "none", "n/a", "", "i don't know", "unknown"]:
-                print(f"[✅ AGENT]: {answer}")
-                return answer
-            print(f"[⚠️ AGENT risposta vuota/invalida: '{answer}'] → fallback")
-        except Exception as e:
-            print(f"[⚠️ AGENT CRASH: {e}] → fallback")
+    def _handle_special_cases(self, question: str, task_id: str, file_context: str) -> str:
+        """Gestisci direttamente casi speciali che non richiedono l'agente."""
+        q_lower = question.lower()
 
-        # Tentativo 2: chiamata diretta HF API
-        return call_hf_direct(processed)
+        # --- EXCEL con domanda su totali/somme ---
+        if file_context and ("total" in q_lower or "sum" in q_lower or "sales" in q_lower):
+            try:
+                # Prova a parsare il contesto come DataFrame
+                if file_context.startswith("Excel:") or file_context.startswith("CSV"):
+                    # Ri-scarica il file e calcola
+                    file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+                    resp = requests.get(file_url, timeout=15)
+                    ct = resp.headers.get("Content-Type", "")
+                    cd = resp.headers.get("Content-Disposition", "")
+                    filename = ""
+                    if "filename=" in cd:
+                        filename = cd.split("filename=")[-1].strip('" ')
+                    ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+
+                    if "spreadsheet" in ct or "excel" in ct or ext in ["xlsx", "xls"]:
+                        df = pd.read_excel(io.BytesIO(resp.content), engine="openpyxl")
+                    elif ext == "csv" or "csv" in ct:
+                        df = pd.read_csv(io.BytesIO(resp.content))
+                    else:
+                        return ""
+
+                    # Trova colonne numeriche e calcola totali
+                    numeric_cols = df.select_dtypes(include=["number"]).columns.tolist()
+                    if numeric_cols:
+                        totals = {col: df[col].sum() for col in numeric_cols}
+                        # Se chiede "total sales", cerca colonna "sales"
+                        for col in numeric_cols:
+                            if "sale" in col.lower() or "total" in col.lower() or "amount" in col.lower():
+                                val = df[col].sum()
+                                # Formatta come numero intero se è un intero
+                                if val == int(val):
+                                    return str(int(val))
+                                return f"${val:,.2f}" if val > 100 else str(val)
+                        # Altrimenti somma la prima colonna numerica
+                        val = list(totals.values())[0]
+                        if val == int(val):
+                            return str(int(val))
+                        return str(val)
+            except Exception as e:
+                print(f"  [SPECIAL CASE Excel error]: {e}")
+
+        return ""
 
 
 # ==========================================
@@ -274,11 +544,14 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         return "Per favore, fai il Login con Hugging Face.", None
 
     username = profile.username
-    print(f"Utente: {username}")
+    print(f"\n{'='*60}")
+    print(f"👤 Utente: {username}")
+    print(f"{'='*60}")
 
     try:
         agent = SuperAgent()
     except Exception as e:
+        traceback.print_exc()
         return f"Errore inizializzazione agente: {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
@@ -289,63 +562,80 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         questions_data = resp.json()
         if not questions_data:
             return "Lista domande vuota.", None
+        print(f"\n📋 {len(questions_data)} domande da elaborare")
     except Exception as e:
         return f"Errore download domande: {e}", None
 
     results_log = []
     answers_payload = []
 
-    print(f"Elaboro {len(questions_data)} domande...")
-    for item in questions_data:
+    for i, item in enumerate(questions_data):
         task_id = item.get("task_id", "")
         question_text = item.get("question")
         if not task_id or question_text is None:
             continue
+
+        print(f"\n[{i+1}/{len(questions_data)}] ────────────────────────")
         try:
             answer = agent(question_text, task_id=task_id)
         except Exception as e:
             answer = "I don't know"
-            print(f"[LOOP ERROR {task_id}]: {e}")
+            print(f"  [LOOP ERROR]: {e}")
+            traceback.print_exc()
 
         answers_payload.append({"task_id": task_id, "submitted_answer": answer})
         results_log.append({
             "Task ID": task_id,
             "Question": question_text[:120],
-            "Submitted Answer": answer
+            "Submitted Answer": answer,
         })
 
     if not answers_payload:
         return "Nessuna risposta prodotta.", pd.DataFrame(results_log)
 
+    print(f"\n{'='*60}")
+    print(f"📤 Invio {len(answers_payload)} risposte...")
+
     try:
         resp = requests.post(
             f"{DEFAULT_API_URL}/submit",
-            json={"username": username, "agent_code": agent_code, "answers": answers_payload},
-            timeout=60
+            json={
+                "username": username,
+                "agent_code": agent_code,
+                "answers": answers_payload,
+            },
+            timeout=120,
         )
         resp.raise_for_status()
         r = resp.json()
         status = (
             f"✅ Invio Completato!\n"
             f"👤 {r.get('username')}\n"
-            f"🏆 {r.get('score', 'N/A')}% ({r.get('correct_count', '?')}/{r.get('total_attempted', '?')} corrette)\n"
+            f"🏆 {r.get('score', 'N/A')}% "
+            f"({r.get('correct_count', '?')}/{r.get('total_attempted', '?')} corrette)\n"
             f"📝 {r.get('message', '')}"
         )
+        print(f"\n{status}")
         return status, pd.DataFrame(results_log)
     except Exception as e:
         return f"❌ Invio fallito: {e}", pd.DataFrame(results_log)
 
 
 # ==========================================
-# 🖥️ INTERFACCIA
+# 🖥️ INTERFACCIA GRADIO
 # ==========================================
 with gr.Blocks() as demo:
     gr.Markdown("# 🚀 Super Agente - Final Assignment Runner")
+    gr.Markdown(
+        "Login con HF, poi clicca il bottone. "
+        "L'agente proverà più modelli e strategie per rispondere al GAIA benchmark."
+    )
     gr.LoginButton()
-    run_button = gr.Button("Avvia Valutazione & Invia Risposte", variant="primary")
-    status_output = gr.Textbox(label="Stato / Risultato", lines=5, interactive=False)
+    run_button = gr.Button("🔥 Avvia Valutazione & Invia Risposte", variant="primary")
+    status_output = gr.Textbox(label="Stato / Risultato", lines=6, interactive=False)
     results_table = gr.DataFrame(label="Domande e Risposte", wrap=True)
     run_button.click(fn=run_and_submit_all, outputs=[status_output, results_table])
 
 if __name__ == "__main__":
+    print("🚀 Avvio app...")
     demo.launch(debug=True, share=False)