Update app.py

app.py

@@ -5,43 +5,42 @@ import pandas as pd
 import re
 from datetime import datetime
 import time
-import tempfile # Für temporäre Dateien
-import atexit # Zum Aufräumen beim Beenden
+import tempfile
+import atexit
+import sys # Für sys.exit bei Importfehlern
 
-# --- Smol Agents und HF Imports (KORRIGIERT) ---
+# --- Smol Agents und HF Imports (angepasst an Beispiel) ---
 try:
-    from smolagents import Agent
-    from smolagents.llm.huggingface import InferenceAPI
-    from smolagents.tools import tool
-    print("Successfully imported from 'smolagents'")
+    # 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:
     print(f"Error importing from smolagents: {e}")
     print("Please ensure 'smolagents[huggingface]' is listed correctly in requirements.txt")
-    # Exit if core library is missing
-    import sys
-    sys.exit(f"Fatal Error: Could not import smolagents. Check requirements.txt and rebuild/restart the Space. Original error: {e}")
+    sys.exit(f"Fatal Error: Could not import smolagents components. Check requirements.txt and rebuild/restart the Space. Original error: {e}")
 
-from huggingface_hub import HfApi, InferenceClient
+# huggingface_hub wird möglicherweise von HfApiModel intern genutzt
+from huggingface_hub import HfApi
 
-# --- 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)
+# --- Suchtool Imports (wie zuvor) ---
+USE_TAVILY = False
+USE_DUCKDUCKGO = True
 
 if USE_TAVILY:
     try:
         from tavily import TavilyClient
     except ImportError:
-        print("WARNUNG: TavilyClient nicht installiert. Führe 'pip install tavily-python' aus.")
+        print("WARNUNG: TavilyClient nicht installiert.")
         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.")
+         print("WARNUNG: duckduckgo-search nicht installiert.")
          USE_DUCKDUCKGO = False
 
-# --- PDF Reader Import ---
+# --- PDF Reader Import (wie zuvor) ---
 try:
     import PyPDF2
     PDF_READER_AVAILABLE = True
@@ -51,36 +50,36 @@ except ImportError:
 
 # --- Konstanten ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-# Wähle ein Instruction-Following Modell von Hugging Face Hub
-HF_MODEL_ID = os.getenv("HF_MODEL_ID", "meta-llama/Meta-Llama-3-8B-Instruct") # Standardmodell
+# 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 für Clients (werden in initialize_agent gesetzt) ---
-hf_token = None
+# --- Globale Variablen ---
+# search_client wird weiterhin benötigt, da die Tools darauf zugreifen
 search_client = None
-agent_instance = None # Wird pro Lauf initialisiert
+# agent_instance wird pro Lauf initialisiert
+agent_instance = None
 
-# --- Temporäre Datei Verwaltung ---
+# --- 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): # Iteriere über Kopie, da Set verändert wird
+    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: # Prüfe erneut, falls Fehler auftrat
+            if file_path in temp_files_to_clean:
                  temp_files_to_clean.remove(file_path)
         except OSError 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.")
-
-# Registriere die Cleanup-Funktion für das Beenden des Skripts
 atexit.register(cleanup_temp_files)
 
-
-# --- Tool Definitionen für smolagents ---
+# --- Tool Definitionen (unverändert) ---
+# Die @tool-Deklarationen und Funktionslogik bleiben gleich.
 
 @tool
 def search_web(query: str, max_results: int = 3) -> str:
@@ -93,6 +92,7 @@ def search_web(query: str, max_results: int = 3) -> str:
     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:
         return "Search tool is not available/configured."
@@ -107,7 +107,6 @@ def search_web(query: str, max_results: int = 3) -> str:
              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:
-            # Dies sollte nicht passieren, wenn search_client gesetzt ist, aber als Absicherung
             return "No compatible search client configured or available."
     except Exception as e:
         print(f"Search API Error ({type(e).__name__}): {e}")
@@ -124,13 +123,12 @@ def download_task_file(task_id: str) -> str:
         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:
         response = requests.get(file_url, stream=True, timeout=30)
         response.raise_for_status()
-
         content_type = response.headers.get('content-type', '').lower()
         suffix = ".tmp"
         if 'pdf' in content_type: suffix = ".pdf"
@@ -138,36 +136,29 @@ def download_task_file(task_id: str) -> str:
         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"
-        # Füge ggf. weitere Mappings hinzu
-
         temp_dir = tempfile.gettempdir()
         safe_task_id = re.sub(r'[^\w\-]+', '_', task_id)
-        # Erzeuge eindeutigeren Dateinamen, um Konflikte bei schnellen Läufen zu minimieren
         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):
                 f.write(chunk)
-
         print(f"File downloaded successfully to {temp_file_path}")
         temp_files_to_clean.add(temp_file_path)
-        return temp_file_path # Erfolg: Gib Pfad zurück
-
+        return temp_file_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." # Fehler: Gib Fehlermeldung zurück
+            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})." # Fehler
+            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}" # Fehler
+        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} ({type(e).__name__}): {e}")
-        return f"Error: Unexpected error during file download: {e}" # Fehler
+        return f"Error: Unexpected error during file download: {e}"
 
 @tool
 def read_file_content(file_path: str) -> str:
@@ -179,43 +170,35 @@ def read_file_content(file_path: str) -> str:
     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}')")
-
-    # Überprüfung des Inputs: Ist es überhaupt ein Pfad?
     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."
-
-    # Sicherheitscheck: Erlaube nur Lesen aus dem Temp-Verzeichnis (bleibt wichtig)
     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.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)}'." # Gib Dateinamen im Fehler an
-
+        return f"Error: File not found at the specified path '{os.path.basename(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 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)
                 num_pages = len(reader.pages)
                 print(f"Reading {num_pages} pages from PDF...")
                 for page_num in range(num_pages):
-                    # Prüfe ob Seite Text enthält bevor Extraktion versucht wird
                     if reader.pages[page_num].extract_text():
                          page_text = reader.pages[page_num].extract_text()
-                         text += page_text + "\n" # Füge Zeilenumbruch zwischen Seiten hinzu
-                    if len(text) > 7000: # Begrenze die Länge
+                         text += page_text + "\n"
+                    if len(text) > 7000:
                         text = text[:7000] + "\n... (content truncated)"
                         print(f"Text truncated at {len(text)} chars.")
                         break
@@ -224,155 +207,120 @@ def read_file_content(file_path: str) -> str:
                  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: # Versuche als Text zu lesen (TXT, CSV, etc.)
-             # Lese in Chunks um Speicher zu schonen bei großen Textdateien
+        else:
              content = ""
-             chunk_size = 4096
-             max_len = 7000
-             truncated = False
+             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
+                         chunk = f.read(chunk_size);
+                         if not chunk: break
                          content += chunk
-                 if len(content) > max_len:
-                      content = content[:max_len]
-                      truncated = True
+                 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)"
+                 if truncated: result += "\n... (content truncated)"
                  return result
-             except Exception as read_err: # Fange Lesefehler ab
+             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}"
-
-
     except Exception as e:
         print(f"Error reading file {file_path} ({type(e).__name__}): {e}")
         return f"Error: Failed to read file content: {e}"
 
 
-# --- Agent Initialisierung ---
+# --- Agent Initialisierung (VEREINFACHT) ---
 def initialize_agent():
-    """Initialisiert den smolagents Agent und die benötigten Clients."""
-    global hf_token, search_client, agent_instance
+    """Initialisiert den smolagents CodeAgent und die Clients."""
+    global search_client, agent_instance
     print("Initializing agent and clients...")
 
-    # Token und Clients nur einmal initialisieren, wenn nicht vorhanden
-    if not hf_token:
-        hf_token = os.getenv("HUGGINGFACE_TOKEN")
-        if not hf_token:
-            raise ValueError("HUGGINGFACE_TOKEN Secret nicht im Hugging Face Space gefunden!")
-
-    if not search_client:
+    # Initialisiere Search Client (wenn nicht bereits geschehen)
+    if search_client is None:
+        print("Initializing search client...")
         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, obwohl USE_TAVILY=True.")
-                    search_client = None # Verhindere Nutzung
+                try: search_client = TavilyClient(api_key=tavily_key); print("Using Tavily for search.")
+                except NameError: print("WARNUNG: TavilyClient Klasse nicht gefunden."); search_client = None
             else:
-                print("WARNUNG: TAVILY_API_KEY nicht gefunden, obwohl USE_TAVILY=True.")
-                # Fallback nur wenn Tavily nicht genutzt werden konnte
-                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 (Tavily Key fehlt).")
+                print("WARNUNG: TAVILY_API_KEY nicht gefunden.")
+                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 = None
+                else: search_client = None
         elif USE_DUCKDUCKGO:
-            try:
-                search_client = DDGS()
-                print("Using DuckDuckGo for search.")
-            except NameError:
-                search_client = None
-                print("WARNUNG: duckduckgo-search nicht installiert/verfügbar. Suche deaktiviert.")
+            try: search_client = DDGS(); print("Using DuckDuckGo for search.")
+            except NameError: print("WARNUNG: duckduckgo-search nicht installiert/verfügbar."); search_client = None
         else:
-            search_client = None
             print("Web search is disabled by configuration.")
-
-    # Agent Instanz immer neu erstellen oder nur wenn nicht vorhanden?
-    # Für diesen Use Case: Erstelle sie immer neu, um sicherzustellen,
-    # dass sie den neuesten Stand der Tools hat (obwohl sie hier global sind).
-    # Besser wäre es, die tools direkt in der run-Methode zu übergeben.
-
-    # --- LLM Client (Hugging Face Inference API) ---
-    llm = InferenceAPI(
-        model_id=HF_MODEL_ID,
-        token=hf_token,
-        max_new_tokens=1500, # Max Tokens, die das Modell generieren darf
-        temperature=0.1,
-        # stop_sequences=["Observation:", "\nObservation:", "\nTool:", "\nThought:"], # Optional: Hilft manchmal, das Abschneiden zu verbessern
-        # top_p=0.9, # Optional
-    )
-    print(f"LLM configured with model: {HF_MODEL_ID}")
+            search_client = False # Setze auf False, um erneute Initialisierung zu verhindern
+
+    # --- LLM Model (vereinfacht via HfApiModel) ---
+    # HfApiModel sollte HUGGINGFACE_TOKEN und HF_MODEL_ID aus Umgebungsvariablen lesen.
+    # Wir prüfen hier nur, ob das Token vorhanden ist, da HfApiModel es benötigt.
+    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.")
+
+    # Optional: Explizit Model ID übergeben, falls Umgebungsvariable nicht reicht
+    model_config = {}
+    if HF_MODEL_ID:
+         # Prüfe, ob HfApiModel 'model_id' als Argument akzeptiert (Annahme: ja)
+         # Falls nicht, muss man sich auf die Umgebungsvariable verlassen.
+         # Man könnte hier versuchen, das Modell explizit zu setzen:
+         # model_config['model_id'] = HF_MODEL_ID
+         # Wir versuchen es erstmal ohne explizite Übergabe:
+         print(f"HfApiModel will attempt to use model specified by HF_MODEL_ID env var (or its default): {HF_MODEL_ID}")
+         # Man kann auch Parameter direkt übergeben, falls unterstützt:
+         # model_config['max_new_tokens'] = 1500
+         # model_config['temperature'] = 0.1
+
+    hf_model = HfApiModel(**model_config) # Initialisiere mit optionalen Configs
 
     # --- Agent Instanz ---
     available_tools = [search_web, download_task_file, read_file_content]
-    # Filter out None tools if search failed to initialize
-    active_tools = [t for t in available_tools if t is not None]
-
-    # Stelle sicher, dass 'tool' importiert wurde
-    if 'tool' not in globals():
-         raise NameError("Die 'tool' Funktion von smolagents konnte nicht importiert werden.")
+    active_tools = [t for t in available_tools if t is not None] # Filter out None tools (falls search nicht ging)
 
-    agent_instance = Agent(
-        llm=llm,
-        tools=active_tools, # Übergebe die aktiven Tools bei der Initialisierung
-        # system_prompt=... # Kann hier oder im run() prompt definiert werden
+    # Verwende CodeAgent wie im Beispiel
+    agent_instance = CodeAgent(
+        tools=active_tools,
+        model=hf_model
     )
-    print(f"Smol Agent initialized with {len(active_tools)} tools.")
+    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.")
+         print(f"Warning: Some tools might be inactive.")
 
 
-# --- Angepasste Hauptfunktion ---
+# --- Hauptfunktion run_and_submit_all (weitgehend unverändert) ---
+# Die Logik zum Holen der Fragen, Iterieren, Prompt erstellen, Agent aufrufen,
+# Antworten sammeln und Submitten bleibt gleich. Nur die Initialisierung oben ist anders.
 def run_and_submit_all( profile: gr.OAuthProfile | None, progress=gr.Progress(track_tqdm=True)):
     """
-    Fetches all questions, runs the smolagents agent on them, submits all answers,
+    Fetches all questions, runs the smolagents CodeAgent on them, submits all answers,
     and displays the results. Includes Gradio progress tracking.
     """
     space_id = os.getenv("SPACE_ID")
-
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
+    if not profile:
         print("User not logged in.")
-        # Gib None für DataFrame zurück, um Fehler in Gradio zu vermeiden
         return "Please Login to Hugging Face with the button.", None
+    username = f"{profile.username}"
+    print(f"User logged in: {username}")
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Initialisiere Agent und Clients
+    # 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:
-         print(f"Error during initialization: {e}")
-         return f"Configuration Error: {e}", None
-    except Exception as e:
-        print(f"Error initializing agent/clients ({type(e).__name__}): {e}")
-        return f"Error initializing agent: {e}", None
+        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}")
@@ -389,28 +337,22 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, progress=gr.Progress(tr
              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:
-        print(f"Error fetching questions ({type(e).__name__}): {e}")
-        return f"Error fetching questions: {e}", None
+    except Exception as e: return f"Error fetching questions ({type(e).__name__}): {e}", None
 
-
-    # 3. Run your Smol Agent with progress tracking
+    # 3. Run your Smol CodeAgent
     start_time = datetime.now()
     results_log = []
     answers_payload = []
-    print(f"Running smolagents on {num_questions} questions using {HF_MODEL_ID}...")
+    print(f"Running smol CodeAgent on {num_questions} questions using HfApiModel...")
 
-    # Verwende tqdm für die Iteration mit Gradio-Fortschritt
-    # for i, item in enumerate(tqdm(questions_data, desc="Processing Questions")): # Standard tqdm
-    for i, item in enumerate(progress.tqdm(questions_data, desc="Processing Questions")): # Gradio tqdm
+    for i, item in enumerate(progress.tqdm(questions_data, desc="Processing Questions")):
         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}")
             continue
 
-        # --- Prompt für smolagents ---
+        # --- 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.
@@ -435,177 +377,110 @@ Think step-by-step before deciding on an action or the final answer.
 
 Let's begin the thinking process for Task {task_id}.
 """
-
-        submitted_answer = f"Error: Agent failed for task {task_id}" # Default error
+        submitted_answer = f"Error: Agent failed for task {task_id}"
         try:
-            # Führe den Agenten aus (übergebe Tools nicht erneut, wenn sie im Konstruktor sind)
-            agent_response = agent_instance.run(prompt=agent_prompt)
+            # Führe den Agenten aus
+            agent_response = agent_instance.run(prompt=agent_prompt) # Der Aufruf bleibt gleich
 
             if agent_response:
-                 # Einfache Bereinigung: Entferne häufige Präfixe und überflüssige Leerzeichen
-                 # Manchmal geben Modelle trotz Anweisung Präfixe aus.
                  cleaned_response = re.sub(r"^(Final Answer:|Answer:|The answer is:|Here is the answer:)\s*", "", agent_response.strip(), flags=re.IGNORECASE)
-                 # Entferne auch Anführungszeichen am Anfang/Ende, falls das Modell sie hinzufügt
                  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."
-
-
             print(f"Task {task_id} completed. Submitted Answer: '{submitted_answer}'")
 
-        # Handle specific exceptions if needed, e.g., RateLimitError from HF
         except Exception as e:
              error_msg = f"AGENT_RUN_ERROR on task {task_id} ({type(e).__name__}): {e}"
              print(error_msg)
-             submitted_answer = f"ERROR: Agent failed ({type(e).__name__})" # Kürzere Fehlermeldung
+             # Hier könnte man spezifischere Fehler von HfApiModel abfangen, falls bekannt
+             submitted_answer = f"ERROR: Agent failed ({type(e).__name__})"
 
         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})
-            # Optional: Sofortige Bereinigung (kann Laufzeit verlängern)
-            # cleanup_temp_files()
 
-    end_time = datetime.now()
-    duration = end_time - start_time
+    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
+    # 4. Prepare Submission (unverändert)
     if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        cleanup_temp_files() # Aufräumen
+        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}
-    status_update = f"Agent finished in {duration}. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
-
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
-    final_status = "Submission attempt finished." # Default status
-    results_df = pd.DataFrame(results_log) # Erstelle DataFrame vor dem Try-Block
+    print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
 
+    # 5. Submit (unverändert)
+    final_status = "Submission attempt finished."
+    results_df = pd.DataFrame(results_log)
     try:
         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.')}"
-        )
+        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}."
+        error_detail = f"... {e.response.status_code}." # Gekürzte Fehlermeldung für Code-Lesbarkeit
+        # (Vollständige Fehlerbehandlung wie zuvor)
         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]}"
-        final_status = f"Submission Failed: {error_detail}"
-        print(final_status)
-    except requests.exceptions.Timeout:
-        final_status = "Submission Failed: The request timed out."
-        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"An unexpected error occurred during submission ({type(e).__name__}): {e}"
-        print(final_status)
-    finally:
-         cleanup_temp_files() # Stelle sicher, dass aufgeräumt wird
+            error_json = e.response.json(); api_error = error_json.get('detail', e.response.text)
+            if isinstance(api_error, list) and len(api_error) > 0: error_detail += f" Detail: {api_error[0].get('msg', str(api_error))}"
+            else: error_detail += f" Detail: {str(api_error)}"
+        except: error_detail += f" Response: {e.response.text[:200]}"
+        final_status = f"Submission Failed: {error_detail}"; print(final_status)
+    except requests.exceptions.Timeout: final_status = "Submission Failed: Timeout."; 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 ({type(e).__name__}): {e}"; print(final_status)
+    finally: cleanup_temp_files()
 
     progress(1, desc="Done.")
     return final_status, results_df
 
 
-# --- Gradio Interface (mit Progress Bar) ---
+# --- Gradio Interface (weitgehend unverändert) ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Smol Agents Evaluation Runner (Hugging Face)")
-    gr.Markdown(
-        f"""
+    gr.Markdown("# Smol CodeAgent Evaluation Runner (Hugging Face)") # Titel angepasst
+    gr.Markdown(f"""
         **Instructions:**
-
-        1.  Ensure `HUGGINGFACE_TOKEN` (write access) is a Secret in Space settings. Add `TAVILY_API_KEY` if using Tavily.
-        2.  Verify `requirements.txt` includes `smolagents[huggingface]`, search libs, `pypdf2`.
-        3.  Agent uses HF Inference API model: **{HF_MODEL_ID}** (change via `HF_MODEL_ID` env var).
-        4.  Log in below.
-        5.  Click 'Run Evaluation & Submit'. **This will take time.** Monitor progress below and console logs.
-
+        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` library.
-        *   Tools: Web Search ({'Tavily' if USE_TAVILY else 'DuckDuckGo' if USE_DUCKDUCKGO else 'Disabled'}), File Download, File Reading (PDF/Text).
-        """
-    )
-
-    # Platzhalter für Login-Status (vereinfacht)
-    # Gradio's LoginButton handhabt das meiste intern
-    # profile_info = gr.State(None) # Nicht unbedingt nötig, wenn LoginButton direkt genutzt wird
-
-    with gr.Row():
-        login_button = gr.LoginButton()
-        # Logout nicht direkt implementiert, User kann sich auf HF ausloggen
-
+        **Agent Details:** Uses `smolagents.CodeAgent`. Search: {'Tavily' if USE_TAVILY else 'DuckDuckGo' if USE_DUCKDUCKGO else 'Disabled'}.
+        """)
+    with gr.Row(): login_button = gr.LoginButton()
     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)
 
-    # --- Event Handler für den Button ---
-    # Diese Funktion wird aufgerufen, wenn der Button geklickt wird.
-    # Sie erhält das OAuth-Profil, wenn der User eingeloggt ist.
     def handle_run(request: gr.Request):
-         # Das Profil wird aus dem Request-Objekt extrahiert, wenn eingeloggt
          profile = getattr(request, 'profile', None)
-         # Rufe die Hauptfunktion auf und gib ihre Ausgaben zurück
-         # Füge das gr.Progress() Objekt hinzu, das von Gradio verwaltet wird
          return run_and_submit_all(profile, progress=gr.Progress(track_tqdm=True))
 
-    run_button.click(
-        fn=handle_run, # Verwende die Wrapper-Funktion
-        inputs=[],     # Keine expliziten Inputs nötig, Profil kommt vom Request
-        outputs=[status_output, results_table],
-        api_name="run_evaluation_smol"
-    )
-
+    run_button.click(fn=handle_run, inputs=[], outputs=[status_output, results_table], api_name="run_evaluation_smol_codeagent")
 
 # --- App Start (unverändert) ---
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting (Smol Agents Version - Corrected Imports) " + "-"*30)
+    print("\n" + "-"*30 + " App Starting (Smol CodeAgent Version) " + "-"*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}")
-        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}")
-    search_tool_status = 'Disabled'
+    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'
     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 Agents Version - Corrected Imports) ")) + "\n")
-
-    print("Launching Gradio Interface for Smol Agents Evaluation...")
-    # Setze queue=True für bessere Handhabung langer Läufe
+    print("-"*(60 + len(" App Starting (Smol CodeAgent Version) ")) + "\n")
+    print("Launching Gradio Interface for Smol CodeAgent Evaluation...")
     demo.queue().launch(debug=False, share=False)