Update app.py

app.py

@@ -2,128 +2,552 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-from smolagents import CodeAgent, InferenceClientModel
-
-# --- Constants ---
-# API-URL deines Spaces (ohne "/api"-Suffix)
-DEFAULT_API_URL = "https://pmeyhoefer-final-assignment-template.hf.space"
-# Modell-ID und HF-Token (bitte hier deinen HF Access Token einfügen)
-MODEL_ID = os.getenv("SMOL_MODEL_ID", "meta-llama/Llama-3.3-70B-Instruct")
-HF_TOKEN = "<DEIN_HF_HUB_TOKEN>"  # Ersetze durch deinen echten Hugging Face Token
-
-# --- Agent-Implementierung mit smolagents ---
-class BasicAgent:
-    def __init__(self):
-        if not HF_TOKEN or HF_TOKEN.startswith("<"):
-            raise ValueError("Kein gültiger HF_HUB_TOKEN im Code gesetzt!")
-        # InferenceClientModel initialisieren
-        self.model = InferenceClientModel(
-            model_id=MODEL_ID,
-            token=HF_TOKEN
-        )
-        # CodeAgent mit Basis-Tools
-        self.agent = CodeAgent(
-            tools=[],
-            model=self.model,
-            add_base_tools=True
-        )
+import re
+from datetime import datetime
+import time
+import tempfile # Für temporäre Dateien
+import atexit # Zum Aufräumen beim Beenden
+
+# --- Smol Agent und HF Imports ---
+from smol_agent import Agent
+from smol_agent.llm.huggingface import InferenceAPI
+from smol_agent.tools import tool
+from huggingface_hub import HfApi, InferenceClient
+
+# --- Suchtool Imports (wähle eins) ---
+USE_TAVILY = False # Setze auf True, wenn du Tavily bevorzugst (benötigt TAVILY_API_KEY)
+USE_DUCKDUCKGO = True # Setze auf True für DuckDuckGo (kein Key nötig)
+
+if USE_TAVILY:
+    try:
+        from tavily import TavilyClient
+    except ImportError:
+        print("WARNUNG: TavilyClient nicht installiert. Führe 'pip install tavily-python' aus.")
+        USE_TAVILY = False
+        USE_DUCKDUCKGO = True # Fallback
+if USE_DUCKDUCKGO:
+    try:
+        from duckduckgo_search import DDGS
+    except ImportError:
+         print("WARNUNG: duckduckgo-search nicht installiert. Führe 'pip install duckduckgo-search' aus.")
+         USE_DUCKDUCKGO = False
+
+# --- PDF Reader Import ---
+try:
+    import PyPDF2
+    PDF_READER_AVAILABLE = True
+except ImportError:
+    PDF_READER_AVAILABLE = False
+    print("WARNUNG: PyPDF2 nicht installiert. PDF-Lesefunktion ist deaktiviert.")
+
+# --- Konstanten ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+# Wähle ein Instruction-Following Modell von Hugging Face Hub
+# Beispiele: "meta-llama/Meta-Llama-3-8B-Instruct", "mistralai/Mixtral-8x7B-Instruct-v0.1", "google/gemma-1.1-7b-it"
+# Stelle sicher, dass das Modell über die kostenlose Inference API verfügbar ist oder du Inference Endpoints verwendest.
+HF_MODEL_ID = os.getenv("HF_MODEL_ID", "meta-llama/Meta-Llama-3-8B-Instruct") # Standardmodell, kann über Env Var überschrieben werden
+
+# --- Globale Variablen für Clients (werden in initialize_agent gesetzt) ---
+hf_token = None
+search_client = None
+agent_instance = None # Wird pro Lauf initialisiert
+
+# --- Temporäre Datei Verwaltung ---
+temp_files_to_clean = set()
 
-    def __call__(self, question: str) -> str:
+def cleanup_temp_files():
+    print("Cleaning up temporary files...")
+    for file_path in list(temp_files_to_clean):
         try:
-            return self.agent.run(question)
-        except Exception as e:
-            return f"AGENT ERROR: {e}"
-
-# --- Evaluation & Submission ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    # 1. Authentifizierung
-    if not profile:
-        return "Bitte logge dich zuerst bei Hugging Face ein.", None
-    username = profile.username
+            if os.path.exists(file_path):
+                os.remove(file_path)
+                print(f"Removed temporary file: {file_path}")
+            temp_files_to_clean.remove(file_path)
+        except OSError as e:
+            print(f"Error removing temporary file {file_path}: {e}")
+
+# Registriere die Cleanup-Funktion für das Beenden des Skripts
+atexit.register(cleanup_temp_files)
+
+
+# --- Tool Definitionen für smol-agent ---
+
+@tool
+def search_web(query: str, max_results: int = 3) -> str:
+    """
+    Searches the web for the given query and returns a summary of the top results.
+    Use this to find recent information or facts not readily available.
+    Args:
+        query (str): The search query.
+        max_results (int): The maximum number of results to return (default 3).
+    Returns:
+        str: A string containing the search results, or an error message.
+    """
+    print(f"Tool: search_web(query='{query}', max_results={max_results})")
+    if not search_client:
+        return "Search tool is not available/configured."
+    try:
+        if USE_TAVILY and isinstance(search_client, TavilyClient):
+            response = search_client.search(query=query, search_depth="basic", max_results=max_results)
+            context = [{"url": obj["url"], "content": obj["content"]} for obj in response.get('results', [])]
+            if not context: return "No search results found."
+            return "\n".join([f"URL: {c['url']}\nContent: {c['content'][:500]}..." for c in context])
+        elif USE_DUCKDUCKGO and isinstance(search_client, DDGS):
+             results = search_client.text(query, max_results=max_results)
+             if not results: return "No search results found."
+             return "\n".join([f"Title: {r['title']}\nURL: {r['href']}\nSnippet: {r['body'][:500]}..." for r in results])
+        else:
+            return "No compatible search client configured."
+    except Exception as e:
+        print(f"Search API Error: {e}")
+        return f"Error during search: {e}"
+
+@tool
+def download_task_file(task_id: str) -> str:
+    """
+    Downloads a file associated with a specific task ID from the evaluation server.
+    Use this ONLY if the question requires information from a specific file linked to the task.
+    Args:
+        task_id (str): The unique identifier for the task whose file needs to be downloaded.
+    Returns:
+        str: The local path to the downloaded file (e.g., '/tmp/tmpXYZ.pdf') if successful,
+             otherwise an error message or 'No file found'.
+    """
+    print(f"Tool: download_task_file(task_id='{task_id}')")
+    file_url = f"{DEFAULT_API_URL}/files/{task_id}"
+
+    try:
+        response = requests.get(file_url, stream=True, timeout=30) # Erhöhtes Timeout
+        response.raise_for_status() # Löst Fehler für 4xx/5xx aus
+
+        # Bestimme Dateiendung aus Content-Type
+        content_type = response.headers.get('content-type', '').lower()
+        suffix = ".tmp" # Standard-Suffix
+        if 'pdf' in content_type:
+            suffix = ".pdf"
+        elif 'png' in content_type:
+            suffix = ".png"
+        elif 'jpeg' in content_type or 'jpg' in content_type:
+            suffix = ".jpg"
+        elif 'csv' in content_type:
+             suffix = ".csv"
+        elif 'plain' in content_type or 'text' in content_type:
+             suffix = ".txt"
+
+        # Erstelle eine sichere temporäre Datei
+        temp_dir = tempfile.gettempdir()
+        # Verwende task_id im Dateinamen für bessere Nachverfolgbarkeit (optional)
+        safe_task_id = re.sub(r'[^\w\-]+', '_', task_id) # Bereinige task_id für Dateinamen
+        temp_file_path = os.path.join(temp_dir, f"gaia_task_{safe_task_id}{suffix}")
+
+        with open(temp_file_path, 'wb') as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        print(f"File downloaded successfully to {temp_file_path}")
+        temp_files_to_clean.add(temp_file_path) # Füge zur Cleanup-Liste hinzu
+        return temp_file_path # Gib den Pfad zurück
+
+    except requests.exceptions.HTTPError as e:
+        if e.response.status_code == 404:
+            print(f"No file found on server for task_id {task_id}.")
+            return "Error: No file found for this task ID."
+        else:
+            print(f"HTTP Error downloading file for task {task_id}: {e}")
+            return f"Error: Failed to download file (HTTP {e.response.status_code})."
+    except requests.exceptions.RequestException as e:
+        print(f"Network Error downloading file for task {task_id}: {e}")
+        return f"Error: Failed to download file due to network issue: {e}"
+    except Exception as e:
+        print(f"Unexpected error downloading file for task {task_id}: {e}")
+        return f"Error: Unexpected error during file download: {e}"
+
+@tool
+def read_file_content(file_path: str) -> str:
+    """
+    Reads the text content of a previously downloaded file (PDF or plain text).
+    Use this tool AFTER 'download_task_file' has successfully returned a file path.
+    Args:
+        file_path (str): The local path to the file (must be a path returned by 'download_task_file').
+    Returns:
+        str: The extracted text content (truncated if very long), or an error message.
+    """
+    print(f"Tool: read_file_content(file_path='{file_path}')")
+
+    # Sicherheitscheck: Erlaube nur Lesen aus dem Temp-Verzeichnis
+    if not file_path or not file_path.startswith(tempfile.gettempdir()):
+         print(f"Security Alert: Attempted to read file outside temp directory: {file_path}")
+         return "Error: Invalid file path provided. Only downloaded files can be read."
+
+    if not os.path.exists(file_path):
+        print(f"Error: File not found at path: {file_path}")
+        return "Error: File not found at the specified path."
+
+    try:
+        if file_path.lower().endswith(".pdf"):
+            if not PDF_READER_AVAILABLE:
+                return "Error: Cannot read PDF file because PyPDF2 library is not installed."
+            text = ""
+            with open(file_path, 'rb') as f:
+                reader = PyPDF2.PdfReader(f)
+                for page_num in range(len(reader.pages)):
+                    page = reader.pages[page_num]
+                    text += page.extract_text() or "" # Füge leeren String hinzu, falls extract_text None zurückgibt
+                    if len(text) > 7000: # Begrenze die Länge stärker
+                        text = text[:7000] + "\n... (content truncated)"
+                        break
+            print(f"Successfully read ~{len(text)} chars from PDF: {os.path.basename(file_path)}")
+            return f"Content of '{os.path.basename(file_path)}':\n{text}"
+
+        elif file_path.lower().endswith((".png", ".jpg", ".jpeg")):
+             print(f"File is an image: {os.path.basename(file_path)}. Reading image content not implemented.")
+             # Hier könnte man später ein VLM-Tool einbinden
+             return f"Observation: File '{os.path.basename(file_path)}' is an image. Cannot read text content."
+
+        else: # Versuche als Text zu lesen
+             with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                 content = f.read(7000) # Begrenze auf 7000 Zeichen
+                 if len(content) == 7000:
+                     content += "\n... (content truncated)"
+             print(f"Successfully read ~{len(content)} chars from text file: {os.path.basename(file_path)}")
+             return f"Content of '{os.path.basename(file_path)}':\n{content}"
+
+    except Exception as e:
+        print(f"Error reading file {file_path}: {e}")
+        return f"Error: Failed to read file content: {e}"
+
+
+# --- Agent Initialisierung ---
+def initialize_agent():
+    """Initialisiert den smol-agent und die benötigten Clients."""
+    global hf_token, search_client, agent_instance
+    print("Initializing agent and clients...")
+
+    hf_token = os.getenv("HUGGINGFACE_TOKEN")
+    if not hf_token:
+        raise ValueError("HUGGINGFACE_TOKEN Secret nicht im Hugging Face Space gefunden!")
+
+    # --- Search Client ---
+    if USE_TAVILY:
+        tavily_key = os.getenv("TAVILY_API_KEY")
+        if tavily_key:
+            search_client = TavilyClient(api_key=tavily_key)
+            print("Using Tavily for search.")
+        else:
+            print("WARNUNG: TAVILY_API_KEY nicht gefunden, obwohl USE_TAVILY=True.")
+            # Fallback auf DuckDuckGo wenn möglich
+            if USE_DUCKDUCKGO:
+                try:
+                    search_client = DDGS()
+                    print("Falling back to DuckDuckGo for search.")
+                except NameError:
+                     search_client = None
+                     print("WARNUNG: DuckDuckGo auch nicht verfügbar. Suche deaktiviert.")
+            else:
+                search_client = None
+                print("WARNUNG: Suche deaktiviert.")
+    elif USE_DUCKDUCKGO:
+        try:
+            search_client = DDGS()
+            print("Using DuckDuckGo for search.")
+        except NameError:
+            search_client = None
+            print("WARNUNG: DuckDuckGo nicht verfügbar. Suche deaktiviert.")
+    else:
+        search_client = None
+        print("Web search is disabled.")
+
+
+    # --- LLM Client (Hugging Face Inference API) ---
+    llm = InferenceAPI(
+        model_id=HF_MODEL_ID,
+        token=hf_token,
+        max_new_tokens=1500, # Erhöhe ggf. die max. Token für komplexe Antworten
+        temperature=0.1,    # Niedrige Temperatur für Fakten
+        # Weitere Parameter nach Bedarf: top_p, top_k, repetition_penalty etc.
+    )
+    print(f"LLM configured with model: {HF_MODEL_ID}")
+
+    # --- Agent Instanz ---
+    available_tools = [search_web, download_task_file, read_file_content]
+    agent_instance = Agent(
+        llm=llm,
+        # tools=available_tools, # Tools werden dynamisch in run() übergeben
+        # system_prompt=... (optional, kann auch im run() Prompt sein)
+    )
+    print(f"Smol Agent initialized with {len(available_tools)} tools.")
+
+
+# --- Angepasste Hauptfunktion ---
+def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the smol-agent on them, submits all answers,
+    and displays the results.
+    """
     space_id = os.getenv("SPACE_ID")
 
-    # 2. Endpunkte
-    questions_url = f"{DEFAULT_API_URL}/questions"
-    submit_url    = f"{DEFAULT_API_URL}/submit"
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
-    # 3. Agent instanziieren
+    # 1. Initialisiere Agent und Clients (bei jedem Lauf)
     try:
-        agent = BasicAgent()
+        initialize_agent()
+        if not agent_instance: # Zusätzliche Prüfung
+             raise RuntimeError("Agent instance could not be initialized.")
+    except ValueError as e:
+         print(f"Error during initialization: {e}")
+         return f"Configuration Error: {e}", None
     except Exception as e:
-        return f"Fehler beim Initialisieren des Agents: {e}", None
+        print(f"Error initializing agent/clients: {e}")
+        return f"Error initializing agent: {e}", None
 
-    # 4. Fragen abrufen
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Local Run - Code Link N/A"
+    print(f"Agent Code Link: {agent_code}")
+
+    # 2. Fetch Questions (wie zuvor)
+    print(f"Fetching questions from: {questions_url}")
     try:
-        resp = requests.get(questions_url, timeout=15)
-        resp.raise_for_status()
-        questions = resp.json()
+        response = requests.get(questions_url, timeout=30)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data or not isinstance(questions_data, list):
+             print(f"Fetched questions list is empty or invalid format: {questions_data}")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
     except Exception as e:
-        return f"Fehler beim Abrufen der Fragen: {e}", None
-
-    # 5. Antworten generieren
-    records = []
-    answers = []
-    for item in questions:
-        task_id      = item.get("task_id")
-        question_txt = item.get("question") or item.get("instruction", "")
-        if not task_id or not question_txt:
+        # Detailiertere Fehlermeldung
+        print(f"Error fetching questions ({type(e).__name__}): {e}")
+        return f"Error fetching questions: {e}", None
+
+
+    # 3. Run your Smol Agent
+    start_time = datetime.now()
+    results_log = []
+    answers_payload = []
+    print(f"Running smol-agent on {len(questions_data)} questions using {HF_MODEL_ID}...")
+    status_updates = []
+
+    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:
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
-        ans = agent(question_txt)
-        answers.append({
-            "task_id": task_id,
-            "submitted_answer": ans
-        })
-        records.append({
-            "Task ID": task_id,
-            "Question": question_txt,
-            "Antwort": ans
-        })
-
-    if not answers:
-        return "Der Agent hat keine Antworten produziert.", pd.DataFrame(records)
-
-    # 6. Submission
-    submission = {
-        "username":   username.strip(),
-        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
-        "answers":    answers
-    }
+
+        current_status = f"Processing question {i+1}/{len(questions_data)} (Task ID: {task_id})..."
+        print(current_status)
+        status_updates.append(current_status)
+
+        # --- Prompt für smol-agent ---
+        # Wichtig: Klare Anweisung für das Endformat geben!
+        # Gib dem Agenten den Task-ID Kontext mit!
+        agent_prompt = f"""
+You are an expert AI assistant solving a challenge question.
+Your task is to answer the following question accurately and concisely.
+Use the available tools ONLY when necessary to find information or access required files.
+
+**Available Tools:**
+*   `search_web(query: str, max_results: int = 3)`: Searches the web.
+*   `download_task_file(task_id: str)`: Downloads the specific file for a task. Use the task_id '{task_id}' if you need the file for THIS question. Returns the local file path.
+*   `read_file_content(file_path: str)`: Reads text from a downloaded file using the path returned by download_task_file.
+
+**Current Task:**
+*   Task ID: {task_id}
+*   Question: {question_text}
+
+**Instructions:**
+1.  Think step-by-step to break down the question.
+2.  Use the tools provided if you need external information or file content. Make sure to use the correct task_id ('{task_id}') for `download_task_file`.
+3.  Reason through the information obtained.
+4.  Provide ONLY the final answer to the question, without any introductory phrases, explanations, or conversational text like "The answer is..." or "Based on my analysis...".
+5.  Format the answer exactly as requested by the question (e.g., just a year, a comma-separated list, etc.).
+
+Begin!
+"""
+
+        submitted_answer = f"Error: Agent failed to produce a result for task {task_id}" # Default error
+        try:
+            # Führe den Agenten aus
+            agent_response = agent_instance.run(
+                prompt=agent_prompt,
+                tools=[search_web, download_task_file, read_file_content] # Übergebe Tools hier
+            )
+
+            if agent_response:
+                 # Versuche, die Antwort zu bereinigen (optional, je nach Modellverhalten)
+                 # Einfache Bereinigung: Entferne häufige Präfixe
+                 cleaned_response = re.sub(r"^(Final Answer:|The answer is:|Here is the answer:)\s*", "", agent_response.strip(), flags=re.IGNORECASE)
+                 submitted_answer = cleaned_response
+            else:
+                 submitted_answer = "Error: Agent returned an empty response."
+
+
+            print(f"Task {task_id} completed by agent. Raw Response: '{agent_response[:100]}...' | Submitted Answer: '{submitted_answer}'")
+
+        except Exception as e:
+             error_msg = f"SMOL_AGENT ERROR on task {task_id} ({type(e).__name__}): {e}"
+             print(error_msg)
+             # Gib einen Fehler als Antwort ein
+             submitted_answer = f"ERROR: {type(e).__name__}" # Kürzere Fehlermeldung für die Payload
+
+        finally:
+            # Füge das Ergebnis (oder den Fehler) hinzu
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            # Bereinige temporäre Dateien *sofort* nach Bearbeitung der Aufgabe
+            # (Optional, atexit macht es auch am Ende)
+            # cleanup_temp_files() # Kann hier aufgerufen werden, wenn Ressourcen knapp sind
+
+    end_time = datetime.now()
+    duration = end_time - start_time
+    print(f"Agent processing finished in {duration}.")
+
+    # 4. Prepare Submission (wie zuvor)
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        # Lösche übrig gebliebene Temp-Dateien
+        cleanup_temp_files()
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished in {duration}. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit (wie zuvor, mit Timeout)
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        resp = requests.post(submit_url, json=submission, timeout=60)
-        resp.raise_for_status()
-        result = resp.json()
-        status = (
-            f"Erfolgreich eingereicht!\n"
-            f"User: {result.get('username')}\n"
-            f"Score: {result.get('score')}% "
-            f"({result.get('correct_count')}/{result.get('total_attempted')})\n"
-            f"Nachricht: {result.get('message')}"
+        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Score: {result_data.get('score', 'N/A'):.2f}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
         )
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status + f"\n\nAgent ({HF_MODEL_ID}) Processing Log:\n" + "\n".join(status_updates[-5:]), results_df
+    except requests.exceptions.HTTPError as e:
+        # (Fehlerbehandlung wie zuvor)
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            api_error = error_json.get('detail', e.response.text)
+            if isinstance(api_error, list) and len(api_error) > 0 and isinstance(api_error[0], dict):
+                 error_detail += f" Detail: {api_error[0].get('msg', str(api_error))}"
+            else:
+                 error_detail += f" Detail: {str(api_error)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        # ... (Rest der Fehlerbehandlung wie zuvor) ...
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
-        status = f"Fehler bei der Einreichung: {e}"
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    finally:
+         # Stelle sicher, dass alle Temp-Dateien am Ende gelöscht werden
+         cleanup_temp_files()
 
-    df = pd.DataFrame(records)
-    return status, df
 
-# --- Gradio UI ---
+# --- Gradio Interface (angepasst für smol-agent) ---
 with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner")
-    gr.Markdown("""
-1. Füge in den Space-Secrets deinen `HF_HUB_TOKEN` ein (oder setze ihn direkt im Code oben).
-2. Optional: Lege `SMOL_MODEL_ID` in den Secrets an (Standard: meta-llama/Llama-3.3-70B-Instruct).
-3. Aktualisiere `requirements.txt` mit:
-4. Commit & Push, warte auf Deployment.
-5. Logge dich mit dem Hugging Face Button ein.
-6. Klicke auf **Run Evaluation & Submit All Answers**.
-    """)
+    gr.Markdown("# Smol Agent Evaluation Runner (Hugging Face)")
+    gr.Markdown(
+        f"""
+        **Instructions:**
+
+        1.  Ensure you have added your `HUGGINGFACE_TOKEN` (with write access) as a Secret in your Space settings. Optionally add `TAVILY_API_KEY` if using Tavily search.
+        2.  Make sure `requirements.txt` includes `smol-agent[huggingface]`, search libraries (`duckduckgo-search` or `tavily-python`), and `pypdf2`.
+        3.  The agent uses the Hugging Face Inference API with the model: **{HF_MODEL_ID}**. You can change this by setting the `HF_MODEL_ID` environment variable in your Space settings.
+        4.  Log in to your Hugging Face account below.
+        5.  Click 'Run Evaluation & Submit All Answers'. **This will take time** as the agent processes each question using the Inference API.
+
+        ---
+        **Agent Details:**
+        *   Uses the `smol-agent` library.
+        *   Leverages Hugging Face Inference API for LLM calls.
+        *   Tools: Web Search ({'Tavily' if USE_TAVILY else 'DuckDuckGo' if USE_DUCKDUCKGO else 'Disabled'}), File Download, File Reading (PDF/Text).
+        *   Check the Space console logs for detailed agent behavior.
+        """
+    )
+
     gr.LoginButton()
-    run_btn      = gr.Button("Run Evaluation & Submit All Answers")
-    status_out   = gr.Textbox(label="Status / Ergebnis", lines=5, interactive=False)
-    result_table = gr.DataFrame(label="Fragen & Antworten", wrap=True)
-    run_btn.click(fn=run_and_submit_all, inputs=[], outputs=[status_out, result_table])
 
-if __name__ == "__main__":
-    demo.launch(debug=True)
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=10, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True, height=400)
+
+    # Verwende profile als Input für die Funktion
+    def get_profile(request: gr.Request):
+        # Helper function to potentially extract profile info if needed later,
+        # Gradio's LoginButton might handle profile implicitly now.
+        # For now, just pass None if not logged in via button state.
+        # This part might need adjustment based on how Gradio passes OAuthProfile.
+        # The current run_and_submit_all signature expects OAuthProfile | None
+        # which Gradio should provide when the button is clicked if logged in.
+        # If run_button.click doesn't automatically pass the profile,
+        # we might need a different setup using gr.State or gr.Variable.
+        # Let's assume Gradio handles passing the profile for now.
+        pass # Placeholder
 
+    run_button.click(
+        fn=run_and_submit_all,
+        inputs=[], # Gradio's LoginButton should implicitly provide profile context
+                   # If this fails, might need inputs=gr.State(profile_info) setup
+        outputs=[status_output, results_table],
+        api_name="run_evaluation_smol"
+    )
+
+# --- App Start (unverändert) ---
 if __name__ == "__main__":
- demo.launch(debug=True)
+    print("\n" + "-"*30 + " App Starting (Smol Agent Version) " + "-"*30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+
+    # (Rest des Startblocks unverändert)
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup:
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print(f"   Using HF Model via Inference API: {HF_MODEL_ID}")
+    print(f"   Search Tool: {'Tavily' if USE_TAVILY else 'DuckDuckGo' if USE_DUCKDUCKGO else 'Disabled'}")
+    print("-"*(60 + len(" App Starting (Smol Agent Version) ")) + "\n")
+
+    print("Launching Gradio Interface for Smol Agent Evaluation...")
+    demo.launch(debug=False, share=False) # Debug=False für normalen Betrieb