Update app.py

app.py

@@ -7,11 +7,10 @@ from datetime import datetime
 import time
 import tempfile
 import atexit
-import sys # Für sys.exit bei Importfehlern
+import sys  # Für sys.exit bei Importfehlern
 
 # --- Smol Agents und HF Imports (angepasst an Beispiel) ---
 try:
-    # Verwende CodeAgent und HfApiModel wie im Beispiel
     from smolagents import CodeAgent, tool, HfApiModel
     print("Successfully imported CodeAgent, tool, HfApiModel from 'smolagents'")
 except ImportError as e:
@@ -19,28 +18,26 @@ except ImportError as e:
     print("Please ensure 'smolagents[huggingface]' is listed correctly in requirements.txt")
     sys.exit(f"Fatal Error: Could not import smolagents components. Check requirements.txt and rebuild/restart the Space. Original error: {e}")
 
-# huggingface_hub wird möglicherweise von HfApiModel intern genutzt
 from huggingface_hub import HfApi
 
-# --- Suchtool Imports (wie zuvor) ---
-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)
-
+# --- Suchtool Imports ---
+USE_TAVILY = False
+USE_DUCKDUCKGO = True
 if USE_TAVILY:
     try:
         from tavily import TavilyClient
     except ImportError:
         print("WARNUNG: TavilyClient nicht installiert.")
         USE_TAVILY = False
-        USE_DUCKDUCKGO = True # Fallback
+        USE_DUCKDUCKGO = True
 if USE_DUCKDUCKGO:
     try:
         from duckduckgo_search import DDGS
     except ImportError:
-         print("WARNUNG: duckduckgo-search nicht installiert.")
-         USE_DUCKDUCKGO = False
+        print("WARNUNG: duckduckgo-search nicht installiert.")
+        USE_DUCKDUCKGO = False
 
-# --- PDF Reader Import (wie zuvor) ---
+# --- PDF Reader Import ---
 try:
     import PyPDF2
     PDF_READER_AVAILABLE = True
@@ -50,68 +47,49 @@ except ImportError:
 
 # --- Konstanten ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-# HfApiModel liest dies wahrscheinlich aus der Umgebungsvariable HF_MODEL_ID
-# oder hat einen internen Default. Wir setzen sie weiterhin als Fallback/Info.
 HF_MODEL_ID = os.getenv("HF_MODEL_ID", "meta-llama/Meta-Llama-3-8B-Instruct")
 
 # --- Globale Variablen ---
-# search_client wird weiterhin benötigt, da die Tools darauf zugreifen
 search_client = None
-# agent_instance wird pro Lauf initialisiert
 agent_instance = None
 
-# --- Temporäre Datei Verwaltung (wie zuvor) ---
 temp_files_to_clean = set()
+
 def cleanup_temp_files():
-    # (Code unverändert)
     print("Cleaning up temporary files...")
     for file_path in list(temp_files_to_clean):
         try:
             if os.path.exists(file_path):
                 os.remove(file_path)
                 print(f"Removed temporary file: {file_path}")
-            if file_path in temp_files_to_clean:
-                 temp_files_to_clean.remove(file_path)
-        except OSError as e:
+            temp_files_to_clean.discard(file_path)
+        except Exception as e:
             print(f"Error removing temporary file {file_path}: {e}")
-        except KeyError:
-             print(f"Warning: File path {file_path} already removed from cleanup set.")
-atexit.register(cleanup_temp_files)
 
-# --- Tool Definitionen (unverändert) ---
-# Die @tool-Deklarationen und Funktionslogik bleiben gleich.
+atexit.register(cleanup_temp_files)
 
+# --- Tool Definitionen ---
 @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.
-    """
-    # (Code unverändert)
     print(f"Tool: search_web(query='{query}', max_results={max_results})")
     if not search_client:
-        # Extra Check, ob search_client explizit auf False gesetzt wurde (Initialisierung fehlgeschlagen)
-        if search_client is False:
-            return "Search tool is disabled by configuration or missing libraries."
-        else:
-            # Sollte nicht passieren, wenn initialize_agent korrekt läuft, aber zur Sicherheit
-             print("Warning: Search client not initialized before tool use.")
-             return "Search tool is not available/configured."
+        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])
+            context = 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])
+            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 or available."
     except Exception as e:
@@ -120,16 +98,6 @@ def search_web(query: str, max_results: int = 3) -> str:
 
 @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/gaia_task_abc-123.pdf') if successful,
-             otherwise an error message starting with 'Error:'.
-    """
-    # (Code unverändert)
     print(f"Tool: download_task_file(task_id='{task_id}')")
     file_url = f"{DEFAULT_API_URL}/files/{task_id}"
     try:
@@ -141,381 +109,128 @@ def download_task_file(task_id: str) -> str:
         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"
         temp_dir = tempfile.gettempdir()
-        safe_task_id = re.sub(r'[^\w\-]+', '_', task_id)
+        safe_id = re.sub(r'[^\w\-]+', '_', task_id)
         timestamp = datetime.now().strftime("%Y%m%d%H%M%S%f")
-        temp_file_path = os.path.join(temp_dir, f"gaia_task_{safe_task_id}_{timestamp}{suffix}")
-        with open(temp_file_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=8192):
+        path = os.path.join(temp_dir, f"gaia_task_{safe_id}_{timestamp}{suffix}")
+        with open(path, 'wb') as f:
+            for chunk in response.iter_content(8192):
                 f.write(chunk)
-        print(f"File downloaded successfully to {temp_file_path}")
-        temp_files_to_clean.add(temp_file_path)
-        return temp_file_path
+        temp_files_to_clean.add(path)
+        return path
     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}"
+        return f"Error: Failed to download file (HTTP {e.response.status_code})."
     except Exception as e:
-        print(f"Unexpected error downloading file for task {task_id} ({type(e).__name__}): {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 (not an error message).
-    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 starting with 'Error:'.
-    """
-    # (Code weitgehend unverändert, ggf. kleine Optimierungen wie zuvor)
     print(f"Tool: read_file_content(file_path='{file_path}')")
-    if not isinstance(file_path, str) or not os.path.isabs(file_path):
-         print(f"Invalid input for read_file_content: '{file_path}'. Expected an absolute file path.")
-         return "Error: Invalid input. Provide the absolute file path returned by download_task_file."
-    if 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.isabs(file_path) or not file_path.startswith(tempfile.gettempdir()):
+        return "Error: Invalid file path provided."
     if not os.path.exists(file_path):
-        print(f"Error: File not found at path: {file_path}")
-        return f"Error: File not found at the specified path '{os.path.basename(file_path)}'."
+        return f"Error: File not found '{file_path}'."
     try:
-        file_size = os.path.getsize(file_path)
-        print(f"Reading file: {os.path.basename(file_path)}, Size: {file_size} bytes")
-        if file_size == 0:
-             print(f"Warning: File {os.path.basename(file_path)} is empty.")
-             return f"Observation: The file '{os.path.basename(file_path)}' is empty."
-        if file_path.lower().endswith(".pdf"):
-            if not PDF_READER_AVAILABLE: return "Error: Cannot read PDF file because PyPDF2 library is not installed."
+        if file_path.lower().endswith('.pdf'):
+            if not PDF_READER_AVAILABLE:
+                return "Error: PyPDF2 not installed."
             text = ""
             with open(file_path, 'rb') as f:
                 reader = PyPDF2.PdfReader(f)
-                num_pages = len(reader.pages)
-                print(f"Reading {num_pages} pages from PDF...")
-                for page_num in range(num_pages):
-                    if reader.pages[page_num].extract_text():
-                         page_text = reader.pages[page_num].extract_text()
-                         text += page_text + "\n"
+                for p in reader.pages:
+                    text += p.extract_text() or ''
                     if len(text) > 7000:
-                        text = text[:7000] + "\n... (content truncated)"
-                        print(f"Text truncated at {len(text)} chars.")
+                        text = text[:7000] + "\n... (truncated)"
                         break
-            if not text:
-                 print(f"Warning: Could not extract text from PDF: {os.path.basename(file_path)}")
-                 return f"Observation: Could not extract any text content from the PDF file '{os.path.basename(file_path)}'."
-            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", ".gif", ".bmp")):
-             print(f"File is an image: {os.path.basename(file_path)}. Reading image content not implemented.")
-             return f"Observation: File '{os.path.basename(file_path)}' is an image. Cannot read text content with this tool."
         else:
-             content = ""
-             chunk_size = 4096; max_len = 7000; truncated = False
-             try:
-                 with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
-                     while len(content) < max_len:
-                         chunk = f.read(chunk_size);
-                         if not chunk: break
-                         content += chunk
-                 if len(content) > max_len: content = content[:max_len]; truncated = True
-                 print(f"Successfully read ~{len(content)} chars from text file: {os.path.basename(file_path)}")
-                 result = f"Content of '{os.path.basename(file_path)}':\n{content}"
-                 if truncated: result += "\n... (content truncated)"
-                 return result
-             except Exception as read_err:
-                 print(f"Error reading file {file_path} as text: {read_err}")
-                 return f"Error: Failed to read file '{os.path.basename(file_path)}' as text: {read_err}"
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                content = f.read(7000)
+            return f"Content of '{os.path.basename(file_path)}':\n{content}"
     except Exception as e:
-        print(f"Error reading file {file_path} ({type(e).__name__}): {e}")
-        return f"Error: Failed to read file content: {e}"
+        return f"Error: Failed to read file: {e}"
 
-
-# --- Agent Initialisierung (VEREINFACHT) ---
+# --- Agent Initialisierung ---
 def initialize_agent():
-    """Initialisiert den smolagents CodeAgent und die Clients."""
     global search_client, agent_instance
-    print("Initializing agent and clients...")
-
-    # Initialisiere Search Client (wenn nicht bereits geschehen oder fehlgeschlagen)
-    if search_client is None: # Nur initialisieren, wenn noch nicht versucht
-        print("Initializing search client...")
+    if search_client is None:
         if USE_TAVILY:
-            tavily_key = os.getenv("TAVILY_API_KEY")
-            if tavily_key:
-                try: search_client = TavilyClient(api_key=tavily_key); print("Using Tavily for search.")
-                except NameError: print("WARNUNG: TavilyClient Klasse nicht gefunden."); search_client = False # Fehler markieren
+            key = os.getenv("TAVILY_API_KEY")
+            if key:
+                try: search_client = TavilyClient(api_key=key)
+                except: search_client = False
             else:
-                print("WARNUNG: TAVILY_API_KEY nicht gefunden.")
-                search_client = False # Fehler markieren
-                if USE_DUCKDUCKGO: # Fallback nur wenn Tavily nicht initialisiert werden konnte
-                    try: search_client = DDGS(); print("Falling back to DuckDuckGo for search.")
-                    except NameError: print("WARNUNG: DuckDuckGo nicht verfügbar."); search_client = False # Fehler markieren
+                search_client = False
         elif USE_DUCKDUCKGO:
-            try: search_client = DDGS(); print("Using DuckDuckGo for search.")
-            except NameError: print("WARNUNG: duckduckgo-search nicht installiert/verfügbar."); search_client = False # Fehler markieren
+            try: search_client = DDGS()
+            except: search_client = False
         else:
-            print("Web search is disabled by configuration.")
-            search_client = False # Explizit deaktiviert
-
-    # --- LLM Model (vereinfacht via HfApiModel) ---
-    hf_token_check = os.getenv("HUGGINGFACE_TOKEN")
-    if not hf_token_check:
-        raise ValueError("HUGGINGFACE_TOKEN Secret nicht im Hugging Face Space gefunden! HfApiModel benötigt dies.")
-
-    print(f"HfApiModel will attempt to use model specified by HF_MODEL_ID env var (or its default): {HF_MODEL_ID}")
-    model_config = {}
-    # Optional: Parameter für HfApiModel setzen, falls nötig und unterstützt
-    # model_config['max_new_tokens'] = 1500
-    # model_config['temperature'] = 0.1
-
-    hf_model = HfApiModel(**model_config)
-
-    # --- Agent Instanz ---
-    available_tools = [search_web, download_task_file, read_file_content]
-    # Nur aktive Tools übergeben (wenn search_client nicht False ist)
-    active_tools = [t for t in available_tools if t is not None]
+            search_client = False
+    token = os.getenv("HUGGINGFACE_TOKEN")
+    if not token:
+        raise ValueError("HUGGINGFACE_TOKEN Secret nicht gefunden!")
+    hf_model = HfApiModel()
+    tools = [search_web, download_task_file, read_file_content]
     if search_client is False:
-         active_tools = [t for t in active_tools if t != search_web] # Entferne search_web, wenn Client fehlgeschlagen
+        tools = [t for t in tools if t != search_web]
+    agent_instance = CodeAgent(tools=tools, model=hf_model)
 
-    agent_instance = CodeAgent(
-        tools=active_tools,
-        model=hf_model
-    )
-    print(f"Smol CodeAgent initialized with {len(active_tools)} tools and HfApiModel.")
-    if len(active_tools) < len(available_tools):
-         print(f"Warning: Some tools might be inactive due to configuration or missing libraries.")
-
-
-# --- Hauptfunktion run_and_submit_all (Nimmt gr.Request) ---
-def run_and_submit_all( request: gr.Request, progress=gr.Progress(track_tqdm=True)): # Geänderter Parameter
-    """
-    Fetches all questions, runs the smolagents CodeAgent on them, submits all answers,
-    and displays the results. Includes Gradio progress tracking.
-    """
-    # +++ Profil aus Request extrahieren +++
-    profile = getattr(request, 'profile', None)
-    # +++ DEBUGGING PRINT (wie zuvor) +++
-    print(f"--- Entering run_and_submit_all ---")
-    print(f"Received profile object via request: {profile}")
-    if profile:
-        print(f"Profile username: {getattr(profile, 'username', 'N/A')}")
-        # print(f"Profile details: {vars(profile) if profile else 'N/A'}") # Details können viel loggen
-    else:
-        print("Profile object via request is None.")
-    # +++ END DEBUGGING PRINT +++
-
-    space_id = os.getenv("SPACE_ID")
-
-    # *** HIER die eigentliche Prüfung ***
+# --- Hauptfunktion run_and_submit_all ---
+def run_and_submit_all(profile, progress=gr.Progress(track_tqdm=True)):
     if not profile:
-        print("Condition 'if not profile:' is TRUE. Returning login message.")
-        return "Please Login to Hugging Face with the button.", None
-
-    # Ab hier sollte der Code nur laufen, wenn profile NICHT None ist
-    username = f"{profile.username}" # Jetzt sicher, da profile nicht None ist
-    print(f"Proceeding with run for user: {username}")
-
+        return "Bitte zuerst mit Hugging Face einloggen.", None
+    username = profile.username if hasattr(profile, 'username') else profile['username']
     api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
-
-    # 1. Initialisiere Agent (vereinfacht)
-    progress(0, desc="Initializing Agent...")
     try:
         initialize_agent()
-        if not agent_instance: raise RuntimeError("Agent instance could not be initialized.")
-    except ValueError as e: return f"Configuration Error: {e}", None
-    except Exception as e: return f"Error initializing agent ({type(e).__name__}): {e}", None
-
-    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
-    progress(0.1, desc="Fetching questions...")
-    print(f"Fetching questions from: {questions_url}")
-    try:
-        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
-        num_questions = len(questions_data)
-        print(f"Fetched {num_questions} questions.")
-    except Exception as e: return f"Error fetching questions ({type(e).__name__}): {e}", None
-
-    # 3. Run your Smol CodeAgent
-    start_time = datetime.now()
-    results_log = []
-    answers_payload = []
-    print(f"Running smol CodeAgent on {num_questions} questions using HfApiModel...")
-
-    for i, item in enumerate(progress.tqdm(questions_data, desc="Processing Questions")):
+    except Exception as e:
+        return f"Fehler bei der Agent-Initialisierung: {e}", None
+    questions = requests.get(f"{api_url}/questions", timeout=30).json()
+    answers_log = []
+    payload = []
+    for item in progress.tqdm(questions, desc="Bearbeite Fragen"):
         task_id = item.get("task_id")
-        question_text = item.get("question")
-        if not task_id or question_text is None:
-            print(f"Skipping item {i+1} with missing task_id or question: {item}")
+        question = item.get("question")
+        if not task_id or question is None:
             continue
-
-        # --- Prompt für smolagents (unverändert) ---
-        agent_prompt = f"""
-You are an expert AI assistant solving a challenge question based on the GAIA benchmark.
-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.
-Think step-by-step before deciding on an action or the final answer.
-
-**Available Tools:** (These are the functions you can call)
-*   `search_web(query: str, max_results: int = 3)`: Searches the web for information.
-*   `download_task_file(task_id: str)`: Downloads the specific file FOR THIS TASK ONLY. Use the task_id '{task_id}'. Returns the local file path needed for 'read_file_content'.
-*   `read_file_content(file_path: str)`: Reads text from a file previously downloaded with 'download_task_file'. Requires the exact file path returned by that tool.
-
-**Current Task:**
-*   Task ID: {task_id}
-*   Question: {question_text}
-
-**Instructions & Output Format:**
-1.  Carefully analyze the question.
-2.  Think step-by-step. Outline your plan if needed.
-3.  Execute tools sequentially if information depends on previous steps (e.g., download then read).
-4.  Review the gathered information and your reasoning.
-5.  **Crucially**: Provide ONLY the final answer. Do not include your reasoning, steps, tool calls, introductions (like "The answer is..."), or any other conversational text in the final output. The answer must be exact and stand-alone. Format it as requested by the question (e.g., just a number, a comma-separated list 'apple,banana,orange', etc.).
-
-Let's begin the thinking process for Task {task_id}.
-"""
-        submitted_answer = f"Error: Agent failed for task {task_id}"
+        prompt = f"... Task {task_id}: {question}"
         try:
-            # Führe den Agenten aus
-            agent_response = agent_instance.run(prompt=agent_prompt) # Der Aufruf bleibt gleich
-
-            if agent_response:
-                 cleaned_response = re.sub(r"^(Final Answer:|Answer:|The answer is:|Here is the answer:)\s*", "", agent_response.strip(), flags=re.IGNORECASE)
-                 cleaned_response = cleaned_response.strip('"').strip("'")
-                 submitted_answer = cleaned_response if cleaned_response else "Error: Agent returned empty response after cleaning."
-            else:
-                 submitted_answer = "Error: Agent returned an empty or None response."
-            # Kurze Pause nach jedem Agentenlauf, um Rate Limits etc. zu vermeiden (optional)
-            # time.sleep(0.5)
-
+            resp = agent_instance.run(prompt=prompt)
+            ans = re.sub(r"^(Answer:|Final Answer:)", "", resp or "").strip()
         except Exception as e:
-             error_msg = f"AGENT_RUN_ERROR on task {task_id} ({type(e).__name__}): {e}"
-             print(error_msg)
-             # Hier könnte man spezifischere Fehler von HfApiModel abfangen, falls bekannt
-             submitted_answer = f"ERROR: Agent failed ({type(e).__name__})"
-             # Bei API Fehlern ggf. kurz warten und erneut versuchen (nicht implementiert)
-
-        finally:
-            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})
-            # Logge die konkrete Antwort, die hinzugefügt wird
-            print(f"Task {task_id} logged. Answer added: '{submitted_answer[:100]}...'")
-
-
-    end_time = datetime.now(); duration = end_time - start_time
-    print(f"Agent processing finished in {duration}.")
-    progress(0.9, desc="Submitting answers...")
-
-    # 4. Prepare Submission (unverändert)
-    if not answers_payload:
-        print("Agent did not produce any answers to submit."); 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}
-    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
-    # Debug: Zeige die ersten paar Antworten vor dem Senden
-    print(f"Sample answers payload: {answers_payload[:2]}")
-
-
-    # 5. Submit (unverändert)
-    final_status = "Submission attempt finished."
-    results_df = pd.DataFrame(results_log)
+            ans = f"ERROR: {e}"
+        answers_log.append({"Task ID": task_id, "Question": question, "Submitted Answer": ans})
+        payload.append({"task_id": task_id, "submitted_answer": ans})
+    df = pd.DataFrame(answers_log)
+    submission = {"username": username, "agent_code": "...", "answers": payload}
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=180) # Längeres Timeout für Submit
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (f"Submission Successful!\nUser: {result_data.get('username')}\n"
-                       f"Score: {result_data.get('score', 'N/A'):.2f}% ({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
-                       f"Message: {result_data.get('message', 'No message received.')}")
-        print("Submission successful.")
-    except requests.exceptions.HTTPError as e:
-        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)
-            # Verbesserte Fehleranzeige für Validierungsfehler
-            if isinstance(api_error, list) and api_error and isinstance(api_error[0], dict):
-                 error_msgs = [f"{err.get('loc', ['unknown'])[-1]}: {err.get('msg', '')}" for err in api_error]
-                 error_detail += f" Details: {'; '.join(error_msgs)}"
-            elif isinstance(api_error, str):
-                 error_detail += f" Detail: {api_error[:500]}" # Begrenze Länge
-            else:
-                 error_detail += f" Detail: {str(api_error)[:500]}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Raw Response: {e.response.text[:500]}" # Begrenze Länge
-        final_status = f"Submission Failed: {error_detail}"; print(final_status)
-    except requests.exceptions.Timeout: final_status = "Submission Failed: The request timed out after 180 seconds."; print(final_status)
-    except requests.exceptions.RequestException as e: final_status = f"Submission Failed: Network error - {e}"; print(final_status)
-    except Exception as e: final_status = f"Submission Failed: Unexpected error during submission ({type(e).__name__}): {e}"; print(final_status)
-    finally: cleanup_temp_files()
-
-    progress(1, desc="Done.")
-    return final_status, results_df
-
+        r = requests.post(f"{api_url}/submit", json=submission, timeout=180)
+        r.raise_for_status()
+        res = r.json()
+        status = f"Erfolg! Score: {res.get('score', 0):.2f}%"
+    except Exception as e:
+        status = f"Fehler bei der Submission: {e}"
+    cleanup_temp_files()
+    return status, df
 
-# --- Gradio Interface (Angepasster Button Click) ---
+# --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Smol CodeAgent Evaluation Runner (Hugging Face)") # Titel angepasst
-    gr.Markdown(f"""
-        **Instructions:**
-        1. Ensure `HUGGINGFACE_TOKEN` is a Secret. Add `TAVILY_API_KEY` if using Tavily.
-        2. Verify `requirements.txt` includes `smolagents[huggingface]`, etc.
-        3. Agent uses `CodeAgent` with `HfApiModel`. Target Model (via env var or default): **{HF_MODEL_ID}**.
-        4. Log in below.
-        5. Click 'Run Evaluation & Submit'. Expect a potentially long runtime.
-        ---
-        **Agent Details:** Uses `smolagents.CodeAgent`. Search: {'Tavily' if USE_TAVILY else 'DuckDuckGo' if USE_DUCKDUCKGO else 'Disabled'}.
-        """)
-    with gr.Row(): login_button = gr.LoginButton()
+    gr.Markdown("# Smol CodeAgent Evaluation Runner")
+    gr.Markdown("Bitte einloggen und dann auf Ausführen klicken.")
+    with gr.Row():
+        login_button = gr.LoginButton()
     run_button = gr.Button("Run Evaluation & Submit All Answers")
+    status_output = gr.Textbox(label="Status", lines=5)
+    results_table = gr.DataFrame(label="Ergebnisse")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=10, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True) # Ohne 'height'
-
-    # KORREKTUR: run_and_submit_all direkt aufrufen
-    #            inputs=[] damit Gradio den request Parameter injiziert.
     run_button.click(
         fn=run_and_submit_all,
-        inputs=[], # Wichtig: Keine Inputs hier angeben
+        inputs=[login_button],
         outputs=[status_output, results_table],
         api_name="run_evaluation_smol_codeagent"
     )
 
-# --- App Start (unverändert) ---
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting (Smol CodeAgent Version - Request Fix) " + "-"*30)
-    # (Rest des Startblocks unverändert)
-    space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
-    if space_host_startup: print(f"✅ SPACE_HOST found: {space_host_startup} -> Runtime URL: 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} -> Repo: https://huggingface.co/spaces/{space_id_startup}")
-    else: print("ℹ️  SPACE_ID environment variable not found (running locally?).")
-    print(f"   Using Smol CodeAgent with HfApiModel.")
-    print(f"   Target HF Model (via env var or default): {HF_MODEL_ID}")
-    search_tool_status = 'Disabled';
-    if USE_TAVILY: search_tool_status = 'Tavily'
-    elif USE_DUCKDUCKGO: search_tool_status = 'DuckDuckGo'
-    # Check search client status based on initialization logic
-    if search_client is None and (USE_TAVILY or USE_DUCKDUCKGO): search_tool_status += " (Initialization Pending)"
-    elif search_client is False: search_tool_status += " (Failed to Initialize / Disabled)"
-
-    print(f"   Search Tool: {search_tool_status}")
-    print(f"   PDF Reading: {'Enabled' if PDF_READER_AVAILABLE else 'Disabled (PyPDF2 missing)'}")
-    print("-"*(60 + len(" App Starting (Smol CodeAgent Version - Request Fix) ")) + "\n")
-    print("Launching Gradio Interface for Smol CodeAgent Evaluation...")
-    demo.queue().launch(debug=False, share=False) # queue() ist wichtig
+    demo.queue().launch(debug=False, share=False)