Update app.py

app.py

@@ -1,463 +1,113 @@
 import os
-import gradio as gr
-import requests
-import inspect # This was missing in your latest provided code but is needed for Agent.create_tool
-import pandas as pd
-import logging
 import time
-from datetime import datetime
-from typing import Dict, List, Optional, Any, Generator, Tuple
-from dataclasses import dataclass
-from pathlib import Path
-import hashlib
-import re
-import tempfile
-from PIL import Image
-import soundfile as sf
-import numpy as np
-
-# Core Hugging Face Imports for Agents and Inference
-from huggingface_hub import InferenceClient
-from transformers import pipeline
-from transformers.agents import Agent # This is the main Agent class
-
-# --- Logging Setup (from previous working version) ---
-log_file_name = f"agent_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
-log_path = os.path.join(os.getcwd(), log_file_name)
-
-print(f"[INFO] Log file will be created at: {log_path}")
 
-logging.basicConfig(
-    filename=log_path,
-    filemode='w',
-    level=logging.DEBUG,
-    format='%(asctime)s | %(levelname)-8s | %(funcName)-15s | %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
-
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.INFO)
-console_formatter = logging.Formatter('%(levelname)s: %(message)s')
-console_handler.setFormatter(console_formatter)
-logging.getLogger().addHandler(console_handler)
-
-logging.info(f"===== Application Startup at {datetime.now().isoformat()} =====")
-logging.info(f"📂 Log file configured at: {log_path}")
+import gradio as gr
+import pandas as pd
+import requests
 
+from ShrewdAgent import ShrewdAgent
 
-# --- Constants (from template and my previous suggestions) ---
-# This API URL is for fetching questions and submitting answers
+# (Keep Constants as is)
+# --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# Patterns for extracting the final answer from agent output (crucial for scoring)
-ANSWER_PATTERNS = [
-    r"the answer is:\s*(.*)", r"final_answer\((.*)\)", r"final_answer\(\s*\"(.*?)\"\s*\)",
-    r"final_answer\(\s*'(.*?)'\s*\)", r"final_answer\(\s*```(.*?)```\s*\)",
-    r"final_answer\(\s*`(.*?)`\s*\)", r"final_answer\(\s*\[(.*?)\]\s*\)",
-    r"final_answer\(\s*\{(.*?)\}\s*\)", r"final_answer\(\s*(.*?)\s*\)",
-    r"answer is\s*(.*)", r"final answer is\s*(.*)", r"final answer:\s*(.*)",
-    r"final answer of the question is:\s*(.*)", r"the final answer is:\s*(.*)",
-    r"final answer\s*:\s*(.*)", r"final_answer\s*:\s*(.*)", r"final_answer is\s*(.*)",
-    r"the value is:\s*(.*)", r" (.*)", r"The final answer is: (.*)",
-    r"final answer of the question is (.*)", r"final answer to the question is (.*)",
-    r"final response: (.*)", r"Final Response: (.*)", r"the final response is (.*)",
-    r"Final Response is: (.*)", r"Final Answer:\s*(.*)", r"Final Answer is:\s*(.*)",
-    r"Answer:\s*(.*)", r"The answer is:\s*(.*)", r"Final Answer\s*\[([^\]]+)\]",
-    r"The final answer is\s*\[([^\]]+)\]", r"The answer is\s*\[([^\]]+)\]",
-    r"Answer\s*\[([^\]]+)\]", r"```json\n\{\"answer\":\s*\"(.*?)\"\n\}```",
-    r"```json\n\{\"answer\":\s*(.*?)\n\}```", r"\"answer\":\s*\"(.*?)\"",
-    r"\"answer\":\s*(.*)", r"(\w[\w\s\.\-,\/]*)\s*$", # Broad pattern to catch simple answers at the end
-]
-
-@dataclass
-class QuestionLog:
-    question_num: int
-    question_preview: str
-    question_type: str
-    answer: str
-    processing_time: float
-    status: str
-
-# --- SmartAgent Class (Replaces BasicAgent and your current rule-based one) ---
-class SmartAgent:
-    def __init__(self, username: str, http_session: requests.Session):
-        self.username = username
-        self.http_session = http_session
-        self.agent_id = None
-        self.agent: Optional[Agent] = None
-        self.pipelines = {}
-
-        self.tool_code_cache: Dict[str, str] = {}
-        logging.info("SmartAgent initialized.")
-
-    def setup(self):
-        logging.info("Setting up agent...")
-        try:
-            self.agent = self._initialize_agent()
-            logging.info("Agent setup complete.")
-        except Exception as e:
-            logging.exception(f"Error during agent setup: {e}")
-            raise
-
-    def _initialize_agent(self) -> Agent:
-        logging.info("Initializing Hugging Face Agent...")
-        try:
-            client = InferenceClient() # HF_TOKEN is picked up from environment/secrets
-
-            # The course API manages agent IDs. We check if one exists for the username.
-            # This is the endpoint that previously gave a 404, because BasicAgent
-            # didn't interact with the Agent API side. Now SmartAgent does.
-            # DEFAULT_API_URL handles both questions/submit AND agent creation/tools.
-            list_agents_resp = self.http_session.get(f"{DEFAULT_API_URL}/agents")
-            list_agents_resp.raise_for_status()
-            existing_agents = list_agents_resp.json()
-            logging.debug(f"Existing agents: {existing_agents}")
-
-            for agent_info in existing_agents:
-                if agent_info.get("username") == self.username:
-                    self.agent_id = agent_info["agent_id"]
-                    logging.info(f"Re-using existing agent with ID: {self.agent_id}")
-                    return Agent(id=self.agent_id, client=client)
-
-            # If no existing agent, create a new one
-            create_agent_resp = self.http_session.post(f"{DEFAULT_API_URL}/agents", json={"username": self.username})
-            create_agent_resp.raise_for_status()
-            created_agent_info = create_agent_resp.json()
-            self.agent_id = created_agent_info["agent_id"]
-            logging.info(f"Created new agent with ID: {self.agent_id}")
-            return Agent(id=self.agent_id, client=client)
-
-        except requests.exceptions.RequestException as req_e:
-            logging.error(f"Network or API error during agent initialization: {req_e}")
-            raise
-        except Exception as e:
-            logging.error(f"Unexpected error during agent initialization: {e}")
-            raise
-
-    def _get_tool_code(self, tool_code_hash: str) -> str:
-        if tool_code_hash in self.tool_code_cache:
-            return self.tool_code_cache[tool_code_hash]
-
-        logging.info(f"Fetching tool code for hash: {tool_code_hash}")
-        try:
-            resp = self.http_session.get(f"{DEFAULT_API_URL}/tool_code/{tool_code_hash}")
-            resp.raise_for_status()
-            tool_code = resp.json().get("tool_code", "")
-            if not tool_code:
-                raise ValueError(f"Tool code for hash {tool_code_hash} is empty.")
-            self.tool_code_cache[tool_code_hash] = tool_code
-            return tool_code
-        except requests.exceptions.RequestException as req_e:
-            logging.error(f"Failed to fetch tool code for {tool_code_hash}: {req_e}")
-            raise
-        except Exception as e:
-            logging.error(f"Error getting tool code: {e}")
-            raise
-
-    def __call__(self, question: str, question_type: str, tools_code: Optional[List[Dict]] = None) -> str:
-        # This __call__ method wraps the _execute_agent and _extract_answer
-        # to fit how the main run_and_submit_all expects the agent to be called.
-        if not self.agent:
-            raise ValueError("Agent not initialized. Call setup() first.")
-        
-        agent_raw_output = self._execute_agent(question, question_type, tools_code)
-        extracted_answer = self._extract_answer(agent_raw_output, question_type)
-        return extracted_answer
-
-    def _execute_agent(self, question: str, question_type: str, tools_code: Optional[List[Dict]] = None) -> str:
-        if not self.agent:
-            raise ValueError("Agent not initialized. Call setup() first.")
-
-        logging.info(f"Executing agent for question type '{question_type}': {question[:50]}...")
-        try:
-            special_tools = []
-            if tools_code:
-                for tool_def in tools_code:
-                    tool_code_hash = tool_def.get("tool_code_hash")
-                    tool_name = tool_def.get("tool_name")
-                    if tool_code_hash and tool_name:
-                        tool_code_str = self._get_tool_code(tool_code_hash)
-                        unique_func_name = f"dynamic_tool_func_{hashlib.md5(tool_code_str.encode()).hexdigest()}"
-                        tool_code_str = tool_code_str.replace("def run_tool", f"def {unique_func_name}")
-                        
-                        global_vars = {}
-                        local_vars = {"inputs": None, "tool_code_hash": tool_code_hash} # 'inputs' needed for exec context
-                        # Inject self._run_tool into the execution context so dynamic tools can call it
-                        global_vars['run_tool'] = self._run_tool 
-
-                        exec(tool_code_str, global_vars, local_vars)
-                        
-                        if unique_func_name not in global_vars:
-                            raise ValueError(f"Function {unique_func_name} not found after executing tool code.")
-
-                        special_tools.append(
-                            Agent.create_tool(
-                                name=tool_name,
-                                description=f"Dynamically loaded tool for {tool_name}",
-                                function=global_vars[unique_func_name]
-                            )
-                        )
-                        logging.debug(f"Added dynamic tool: {tool_name}")
-
-            agent_output = self.agent.run(question, additional_tools=special_tools if special_tools else None)
-            raw_answer = agent_output.chat_history[-1].response
-            logging.debug(f"Agent raw output: {raw_answer}")
-            return raw_answer
-        except Exception as e:
-            logging.error(f"Error during agent execution: {e}")
-            raise
-
-    def _extract_answer(self, raw_answer: str, question_type: str) -> str:
-        logging.debug(f"Extracting answer from raw_answer: {raw_answer}")
-        answer = "ERROR"
-        for pattern in ANSWER_PATTERNS:
-            match = re.search(pattern, raw_answer, re.IGNORECASE | re.DOTALL)
-            if match:
-                extracted_content = match.group(1).strip()
-                extracted_content = extracted_content.replace("\\n", "").replace("\\", "")
-                if extracted_content.startswith('"') and extracted_content.endswith('"'):
-                    extracted_content = extracted_content[1:-1]
-                if extracted_content.startswith("'") and extracted_content.endswith("'"):
-                    extracted_content = extracted_content[1:-1]
-                answer = extracted_content
-                logging.debug(f"Extracted answer using pattern '{pattern}': {answer}")
-                break
-        
-        if answer == "ERROR" and raw_answer:
-            # Fallback: if no specific pattern matches, but the raw answer is short and doesn't look like agent internal monologue
-            if len(raw_answer) < 200 and not any(kw in raw_answer.lower() for kw in ["thought", "tool", "action", "observation"]):
-                answer = raw_answer.strip()
-                logging.debug(f"No pattern matched, using raw answer directly: {answer}")
-
-        if not answer: # Ensure 'answer' is not an empty string
-            answer = "ERROR"
-        return answer
-
-    def _load_pipeline(self, pipeline_name: str, **kwargs):
-        if pipeline_name not in self.pipelines:
-            logging.info(f"Loading pipeline: {pipeline_name}")
-            self.pipelines[pipeline_name] = pipeline(pipeline_name, **kwargs)
-        return self.pipelines[pipeline_name]
-
-    def _run_tool(self, tool_name: str, inputs: Dict[str, Any]) -> Any:
-        # This method is called by the dynamically loaded tool code
-        logging.info(f"Running internal tool: {tool_name} with inputs: {inputs}")
-        result = None
-        temp_file_paths = [] # To keep track of temporary files for cleanup
-
-        try:
-            if tool_name == "image-to-text":
-                # Assuming 'image' in inputs is a URL
-                image_url = inputs.get("image")
-                if not image_url:
-                    raise ValueError("Image URL not provided for image-to-text tool.")
-                
-                # Fetch image bytes using the session
-                image_bytes = self.http_session.get(image_url).content
-                
-                # Save to a temporary file
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_img_file:
-                    tmp_img_file.write(image_bytes)
-                    image_path = tmp_img_file.name
-                    temp_file_paths.append(image_path) # Add to cleanup list
-                
-                image = Image.open(image_path)
-                image_to_text_pipeline = self._load_pipeline("image-to-text")
-                result = image_to_text_pipeline(image)[0]["generated_text"]
-                logging.info(f"Image-to-text result: {result[:50]}...")
-
-            elif tool_name == "text-to-image":
-                text_to_image_pipeline = self._load_pipeline("text-to-image", model="runwayml/stable-diffusion-v1-5")
-                images = text_to_image_pipeline(inputs["text"])
-                if images and images.images:
-                    # Save the generated image to a temporary file
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_output_img_file:
-                        images.images[0].save(tmp_output_img_file.name)
-                        result = tmp_output_img_file.name # Return the path to the image
-                        temp_file_paths.append(result)
-                    logging.info(f"Text-to-image result saved to: {result}")
-                else:
-                    logging.warning("Text-to-image pipeline returned no images.")
-                    result = None
-
-            elif tool_name == "speech-to-text":
-                # Assuming 'audio' in inputs is a URL
-                audio_url = inputs.get("audio")
-                if not audio_url:
-                    raise ValueError("Audio URL not provided for speech-to-text tool.")
-
-                audio_bytes = self.http_session.get(audio_url).content
-                with tempfile.NamedTemporaryFile(delete=False, suffix=".flac") as tmp_audio_file:
-                    tmp_audio_file.write(audio_bytes)
-                    audio_path = tmp_audio_file.name
-                    temp_file_paths.append(audio_path)
-
-                speech_to_text_pipeline = self._load_pipeline("automatic-speech-recognition", model="openai/whisper-tiny.en")
-                result = speech_to_text_pipeline(audio_path)["text"]
-                logging.info(f"Speech-to-text result: {result[:50]}...")
-
-            elif tool_name == "text-to-speech":
-                text_to_speech_pipeline = self._load_pipeline("text-to-speech", model="suno/bark-small")
-                speech = text_to_speech_pipeline(inputs["text"])
-                if speech and speech.audio is not None:
-                    # Save the generated audio to a temporary file
-                    with tempfile.NamedTemporaryFile(delete=False, suffix=".flac") as tmp_output_audio_file:
-                        sf.write(tmp_output_audio_file.name, speech.audio.numpy(), samplerate=speech.sampling_rate)
-                        result = tmp_output_audio_file.name # Return the path to the audio
-                        temp_file_paths.append(result)
-                    logging.info(f"Text-to-speech result saved to: {result}")
-                else:
-                    logging.warning("Text-to-speech pipeline returned no audio.")
-                    result = None
-            else:
-                logging.warning(f"Unknown tool: {tool_name}. Skipping execution.")
-                return f"Error: Unknown tool {tool_name}"
-
-            return result
-
-        except Exception as e:
-            logging.error(f"Error running tool '{tool_name}': {e}", exc_info=True)
-            return f"Error running tool {tool_name}: {e}"
-        finally:
-            # Clean up temporary files
-            for fp in temp_file_paths:
-                if os.path.exists(fp):
-                    try:
-                        os.unlink(fp)
-                        logging.debug(f"Cleaned up temporary file: {fp}")
-                    except OSError as e:
-                        logging.warning(f"Could not delete temporary file {fp}: {e}")
-
-    def cleanup(self):
-        logging.info("Cleaning up agent resources...")
-        if self.agent and self.agent_id:
-            try:
-                # The agent API handles cleanup, we don't explicitly delete here.
-                logging.info(f"Agent with ID {self.agent_id} is conceptually deleted (or will expire).")
-            except Exception as e:
-                logging.warning(f"Failed to delete agent or clean up its remote state: {e}")
-        self.pipelines.clear()
-        self.tool_code_cache.clear()
-        logging.info("SmartAgent resources cleaned up.")
-
-# --- Main Run and Submit Function (Modified to use SmartAgent) ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        fixed_answer = "This is a default answer."
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        return fixed_answer
+
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the SmartAgent on them, submits all answers,
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
-    if not profile:
-        logging.info("User not logged in.")
-        yield "Please Login to Hugging Face with the button.", None
-        return
-
-    username = f"{profile.username}"
-    logging.info(f"User logged in: {username}")
-
-    api_url = DEFAULT_API_URL # This is used for questions, submit, agent management, and tool code
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
-    # Determine HF Space Runtime URL and Repo URL for submission
-    space_id = os.getenv("SPACE_ID") 
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "N/A_LOCAL_RUN"
-    logging.info(f"Agent code URL for submission: {agent_code}")
+    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
 
-    # Configure HTTP session with retries for robustness
-    from requests.adapters import HTTPAdapter
-    from urllib3.util.retry import Retry
-    retry_strategy = Retry(
-        total=5,
-        backoff_factor=1,
-        status_forcelist=[429, 500, 502, 503, 504],
-        allowed_methods=["HEAD", "GET", "POST", "PUT", "DELETE", "OPTIONS", "TRACE"]
-    )
-    
-    adapter = HTTPAdapter(max_retries=retry_strategy) 
-    
-    http_session = requests.Session()
-    http_session.mount("https://", adapter)
-    http_session.mount("http://", adapter)
-    
-    agent = None # Initialize agent to None for finally block
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
+    # 1. Instantiate Agent (modify this part to create your agent)
     try:
-        # 1. Instantiate and Setup SmartAgent
-        agent = SmartAgent(username=username, http_session=http_session)
-        agent.setup() # This connects to the /agents endpoint
-
-        # Initial yield for Gradio progress display
-        yield "🚀 Initializing and fetching questions...", pd.DataFrame([])
-
-        # 2. Fetch Questions
-        questions_url = f"{api_url}/questions"
-        logging.info(f"Fetching questions from: {questions_url}")
-        response = http_session.get(questions_url, timeout=15) # Use http_session here
+        agent = ShrewdAgent()
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    # In the case of an app running as a hugging Face space, this link points toward your codebase (usefull for others so please keep it public)
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            logging.warning("Fetched questions list is empty.")
-            yield "Fetched questions list is empty or invalid format.", pd.DataFrame([])
-            return
-        logging.info(f"Fetched {len(questions_data)} questions.")
-
-        # 3. Run your Agent on each question
-        results_log = []
-        answers_payload = []
-        logging.info(f"Running agent on {len(questions_data)} questions...")
-
-        for i, item in enumerate(questions_data, 1):
-            task_id = item.get("task_id")
-            question_text = item.get("question")
-            question_type = item.get("question_type")
-            question_preview = item.get("question_preview", question_text[:50] + "...")
-            tools_code = item.get("tools_code") # Dynamic tool code
-
-            if not all([task_id, question_text is not None, question_type]): # question_text can be empty string
-                logging.warning(f"Skipping item with missing task_id, question, or type: {item}")
-                results_log.append({"Task ID": task_id, "Question": question_preview, "Submitted Answer": "ERROR: Malformed Question", "Status": "ERROR"})
-                continue
-            
-            start_time = time.time()
-            submitted_answer = "ERROR"
-            status = "ERROR"
-
-            try:
-                # Call the SmartAgent's __call__ method
-                submitted_answer = agent(question_text, question_type, tools_code)
-                processing_time = time.time() - start_time
-                status = "OK" if submitted_answer != "ERROR" else "ERROR"
-                logging.info(f"Q{i} [{question_type}] Answer: {submitted_answer} (Took {processing_time:.2f}s)")
-
-                answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer}) # 'submitted_answer' key for submission
-                results_log.append({"Task ID": task_id, "Question": question_preview, "Submitted Answer": submitted_answer, "Status": status})
-
-            except Exception as e:
-                processing_time = time.time() - start_time
-                logging.exception(f"Error running agent on task {task_id}: {e}")
-                submitted_answer = f"AGENT ERROR: {e}"
-                status = "ERROR"
-                answers_payload.append({"task_id": task_id, "submitted_answer": "ERROR"}) # Submit "ERROR"
-                results_log.append({"Task ID": task_id, "Question": question_preview, "Submitted Answer": submitted_answer, "Status": status})
-
-            # Yield progressive updates to Gradio UI
-            yield (
-                f"Processing Q{i}/{len(questions_data)}. Last Answer: {submitted_answer[:100]}",
-                pd.DataFrame(results_log)
-            )
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        file_name = item.get("file_name")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+        try:
+            question_with_attachment = compute_question_with_attachment(question_text, task_id, file_name)
+            submitted_answer = agent(question_with_attachment)
+            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})
+            time.sleep(70) # wait for reducing rate limit errors
+        except Exception as e:
+             print(f"Error running agent on task {task_id}: {e}")
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
-        if not answers_payload:
-            logging.info("Agent did not produce any answers to submit.")
-            yield "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-            return
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-        # 4. Prepare Submission and 5. Submit
-        submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-        submit_url = f"{api_url}/submit"
-        logging.info(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
 
-        response = http_session.post(submit_url, json=submission_data, timeout=120) # Use http_session here
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
-
         final_status = (
             f"Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
@@ -465,10 +115,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        logging.info("Submission successful.")
-        
-        yield final_status, pd.DataFrame(results_log)
-
+        print("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
         try:
@@ -477,70 +126,83 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
+        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."
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
+        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}"
-        logging.error(status_message)
-        yield status_message, pd.DataFrame(results_log)
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
-        status_message = f"An unexpected error occurred during run or submission: {e}"
-        logging.exception(status_message)
-        yield status_message, pd.DataFrame(results_log)
-    finally:
-        if agent:
-            agent.cleanup()
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
 
-# --- Build Gradio Interface using Blocks (as per template) ---
+# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Hugging Face Agent Certification Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
-        1.  This Space uses the official template's structure. Make sure you've cloned it!
-        2.  **Log in to your Hugging Face account using the button below.** This is crucial for authentication and uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your advanced agent, submit answers, and see the score.
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
         ---
         **Disclaimers:**
-        The evaluation process can take significant time as your agent goes through all questions. Progress updates will be shown below.
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
         """
     )
-    
-    # Store the LoginButton in a variable FIRST
-    login_button_component = gr.LoginButton() 
 
-    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers")
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-    # Now, use the variable for the input
     run_button.click(
         fn=run_and_submit_all,
-        inputs=[login_button_component], # <<< THIS IS THE KEY CHANGE >>>
-        outputs=[status_output, results_table],
-        show_progress=True, # Show Gradio's internal progress bar
+        outputs=[status_output, results_table]
     )
 
+
+def compute_question_with_attachment(question: str, task_id: str, file_name: str) -> str:
+    if file_name:
+        return f"{question}\n\nAttached file: https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+    else:
+        return question
+
+
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
     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(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:
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
         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")
+        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("-"*(60 + len(" App Starting ")) + "\n")
-    print("Launching Gradio Interface for Advanced Agent Evaluation...")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)