Update app.py

app.py

@@ -1,652 +1,194 @@
 import os
 import gradio as gr
-import io
-import contextlib
-import re
-import uuid
-try:
-    import spaces  # type: ignore
-except ImportError:
-    # Create a dummy spaces class for local development compatibility
-    class spaces:
-        @staticmethod
-        def GPU():
-            def decorator(func):
-                return func
-            return decorator
-    print("Warning: `spaces` module not found. Using dummy implementation for local execution.")
-
 import requests
 import inspect
 import pandas as pd
-import json
-from typing import List, Dict, Tuple, Union, Optional, TypedDict, Literal
-from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, ToolMessage
-from langchain_core.agents import AgentAction, AgentFinish
-from langchain_core.tools import tool
-from langchain_community.tools.ddg_search import DuckDuckGoSearchRun
-from langchain_huggingface import ChatHuggingFace, HuggingFacePipeline
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langgraph.prebuilt import ToolNode
-from langgraph.graph import StateGraph, END
-from functools import partial
-from transformers import pipeline
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-SYSTEM_PROMPT = """You are a highly meticulous assistant assigned to answer questions precisely.
-Your primary goal is to provide a final answer that directly addresses the user's question and *exactly* matches the required format, with no extra text, commentary, or explanation.
-TOOL USAGE GUIDELINES:
-----------------------
-1. DECISION PROCESS:
-   * First, ALWAYS analyze if the question requires external information or can be answered directly.
-   * For direct questions about basic facts, calculations, or reasoning, do NOT use tools - just answer immediately.
-   * ONLY use tools when the question explicitly or implicitly requires external information.
-2. 'web_search' TOOL USAGE:
-   * Use SPECIFICALLY when you need:
-     - Current events or time-sensitive information (e.g., today's date, recent news).
-     - Specific facts not commonly known (e.g., population of a small town, technical specs).
-     - Statistical data, complex figures, or precise numerical values (e.g., GDP of a country).
-     - Information about recent developments, trends, or changes.
-   * If asked for specific, verifiable facts (names, dates, statistics, events) that are not common knowledge, you MUST use the 'web_search' tool.
-   * When using web_search, provide SPECIFIC search queries focused on exactly what you need. Target the precise piece of information.
-   * DO NOT use broad, general searches like "climate change". Target the exact information needed (e.g., "current CO2 levels 2023 global average ppm").
-3. 'download_file' TOOL USAGE:
-   * Use ONLY when:
-     - The question EXPLICITLY mentions a file, document, or attachment (e.g., "read the file", "in the attached document").
-     - The question refers to information that MUST logically come from a file associated with the provided task_id.
-     - The question contains phrases like "in the document", "from the file", "according to the text provided".
-   * IMPORTANT: Pass ONLY the task_id string to this tool. Nothing else.
-   * DO NOT attempt to download a file if the question doesn't clearly indicate one exists or is necessary.
-4. PROCESS AFTER TOOL USE:
-   * WAIT for the tool's response before proceeding.
-   * EXTRACT only the specific piece of information required by the question from the tool's response.
-   * DO NOT include the full tool response or any commentary about the tool use in your final answer.
-   * FORMULATE your final answer based SOLELY on the relevant information extracted from the tool, adhering strictly to the format rules.
-FINAL ANSWER FORMATTING (CRITICAL):
------------------------------------
-*   Your final response *must* contain ONLY the answer itself, exactly as requested.
-*   Do NOT include any introductory phrases like "The answer is:", "Based on my search:", "Here is the file content:", "The result is:", etc.
-*   If the question asks for a number, respond with ONLY the number (e.g., `42`).
-*   If the question asks for a name, respond with ONLY the name (e.g., `Paris`).
-*   If the question asks for a date, respond with ONLY the date in the requested format (e.g., `2023-10-26`).
-*   If the answer is derived from a downloaded file, extract the specific piece of information requested and return *only* that information.
-*   If you determine you cannot answer the question accurately after using tools or reasoning, respond with only the text: `I cannot answer this question.`
-Example Interaction 1:
-User Question: What is the boiling point of water in Celsius?
-Your Final Answer: 100
-Example Interaction 2:
-User Question: Calculate (5 * 3) + 2
-Your Final Answer: 17
-Example Interaction 3:
-User Question: Read the document associated with task_id 'abc-123' and tell me the value mentioned for 'Project Alpha'.
-(Tool: download_file(task_id='abc-123') -> Returns: "File content: ... Project Alpha: Complete ...")
-Your Final Answer: Complete
-Example Interaction 4 (Requires Web Search):
-User Question: What is the capital of France?
-(LLM decides tool is needed: Request Tool Call `web_search(query='capital of France')`)
-(Tool Result: "Paris is the capital and most populous city of France...")
-(LLM extracts answer from tool result)
-Your Final Answer: Paris
-"""
-
-# --- Agent State Definition ---
-class AgentState(TypedDict):
-    """Represents the state of our agent graph."""
-    question: str                   # The initial question from the API
-    task_id: str                    # Task ID associated with the question
-    agent_outcome: Optional[Union[AgentAction, AgentFinish]] # The latest decision from the agent node
-    intermediate_steps: List[Tuple[AgentAction, str]] # List of (tool action, tool observation) tuples
-    chat_history: List[BaseMessage] # History of messages (human, ai, tool)
-    downloaded_files: Dict[str, str] # Maps task_id to downloaded file content (string)
-    tool_cache: Dict[str, str]       # Cache for tool results {cache_key: result}
-    error: Optional[str]             # To capture any errors during execution
-    max_iterations: int              # Iteration limit
-    current_iteration: int           # Current iteration count
-
-# --- Tool Definitions ---
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
+import requests
+import json
+from typing import List, Dict, Any
+from smolagents import CodeAgent, DuckDuckGoSearchTool, FinalAnswerTool, tool
+from smolagents.models import ChatMessage
+import datetime
+import pytz
+
+
+
 @tool
-def download_file(task_id: str) -> str:
-    """Downloads a required file for a given task ID when the question context
-    indicates a file is needed. Input MUST be the task_id string.
-    Returns the file content as a string on success, or an error message.
+def get_current_time_in_timezone(timezone: str) -> str:
+    """
+    A tool that fetches the current local time in a specified timezone.
+    
+    Args:
+        timezone: A string representing a valid timezone (e.g., 'America/New_York').
     """
-    file_url = f"{DEFAULT_API_URL}/files/{task_id}"
-    print(f"Attempting to download file from: {file_url}")
     try:
-        response = requests.get(file_url, timeout=10)
-        response.raise_for_status()
+        tz = pytz.timezone(timezone)
+        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
+        return f"The current local time in {timezone} is: {local_time}"
+    except Exception as e:
+        return f"Error fetching time for timezone '{timezone}': {str(e)}"
 
-        try:
-            content = response.content.decode('utf-8')
-            print(f"Successfully downloaded and decoded file for task {task_id}. Content length: {len(content)}")
-            summary = f"Successfully downloaded file for task {task_id}. Content starts: {content[:500]}..."
-            return summary
-        except UnicodeDecodeError:
-            print(f"Warning: Could not decode file content as UTF-8 for task {task_id}. Returning raw bytes summary.")
-            return f"Successfully downloaded file for task {task_id}, but it may not be text. Raw content (first 500 bytes): {response.content[:500]}..."
 
-    except requests.exceptions.Timeout:
-        error_msg = f"Error: Timeout occurred while trying to download file for task {task_id} from {file_url}"
-        print(error_msg)
-        return error_msg
-    except requests.exceptions.RequestException as e:
-        status_code = e.response.status_code if e.response else 'N/A'
-        error_msg = f"Error: Failed to download file for task {task_id}. Status code: {status_code}. URL: {file_url}. Error: {e}"
-        print(error_msg)
-        return error_msg
-    except Exception as e:
-        error_msg = f"Error: An unexpected error occurred during file download for task {task_id}: {e}"
-        print(error_msg)
-        return error_msg
-
-web_search = DuckDuckGoSearchRun()
-agent_tools = [download_file, web_search]
-
-# --- Helper Functions for Graph Nodes ---
-def agent_node(state: AgentState, llm_with_tools, prompt):
-    """Runs the LLM to determine the next action or finish."""
-    print(f"Running agent_node (Iteration {state.get('current_iteration', 0)})" )
-    agent_input_dict = {
-        "input": state['question'],
-        "chat_history": state['chat_history'],
-    }
-
-    # Format the prompt explicitly first
-    # The prompt template takes chat_history and input
-    formatted_prompt = prompt.invoke(agent_input_dict)
-    print("Formatted prompt generated for LLM.")
-
-    # --- Add GAIA-specific instructions ---
-    # Convert ChatPromptValue to messages, modify the last HumanMessage
-    messages = formatted_prompt.to_messages()
-    # Use triple quotes for the instruction string
-    gaia_instructions = """\n\nWhen answering, provide ONLY the precise answer requested. Do not include explanations, steps, reasoning, or additional text. Be direct and specific. GAIA benchmark requires exact matching answers. For example, if asked "What is the capital of France?", respond simply with "Paris"."""
-
-    if messages and isinstance(messages[-1], HumanMessage):
-        messages[-1].content += gaia_instructions
-        print("Appended GAIA formatting instructions to the last HumanMessage.")
-    else:
-        # If the last message isn't Human (unexpected), add instructions as a new Human message
-        messages.append(HumanMessage(content=gaia_instructions))
-        print("Warning: Appended GAIA instructions as a new HumanMessage.")
-
-    # Pass the modified messages list to the LLM
-    response = llm_with_tools.invoke(messages)
-
-    # --- Tool Call Handling ---
-    agent_outcome = None # Initialize agent_outcome
-    raw_content = response.content # Get raw content once
-
-    # Check for automatic tool calls first (ideal case)
-    if hasattr(response, 'tool_calls') and response.tool_calls:
-        print(f"Agent decided to call tools (structured): {response.tool_calls}")
-        actions = [
-            # Ensure tool_call_id is included if available directly from the model
-            AgentAction(
-                tool=call['name'], 
-                tool_input=call['args'], 
-                log=str(call),
-                tool_call_id=call.get('id') # Get ID if model provides it
-            )
-            for call in response.tool_calls
-        ]
-        if actions:
-            # If model provides multiple calls, we might need to handle them.
-            # For now, just take the first action if it exists.
-            agent_outcome = actions[0]
-
-    # If no structured tool call, try manual parsing on the stripped content
-    if agent_outcome is None: 
-        # --- Strip prompt echo FIRST ---
-        marker = "<|im_start|>assistant"
-        marker_pos = raw_content.rfind(marker)
-        if marker_pos != -1:
-            final_content = raw_content[marker_pos + len(marker):].lstrip()
-            print(f"Stripped prompt echo for parsing. Content: {final_content[:150]}...")
-        else:
-            final_content = raw_content.strip()
-            print("Assistant marker not found. Parsing raw content.")
-        # --- End Stripping ---
-
-        # --- Manual Parsing on final_content ---
-        search_match = re.search(r"web_search\((.*?)\)", final_content)
-        download_match = re.search(r"download_file\((.*?)\)", final_content)
-        manual_tool_call_id = f"tool_{uuid.uuid4()}" # Generate unique ID
-
-        if search_match:
-            tool_input_str = search_match.group(1).strip()
-            try:
-                # Try parsing as dict {'query': '...'} first
-                parsed_input = json.loads(tool_input_str.replace("'", '"')) # Replace single quotes for JSON
-                if isinstance(parsed_input, dict) and 'query' in parsed_input:
-                     tool_input = parsed_input
-                else:
-                     # If not a dict with 'query', assume the string itself is the query
-                     tool_input = {"query": tool_input_str}
-            except json.JSONDecodeError:
-                # Handle plain string query: web_search("the query") or web_search('the query')
-                if (tool_input_str.startswith("'") and tool_input_str.endswith("'")) or \
-                   (tool_input_str.startswith('"') and tool_input_str.endswith('"')):
-                    tool_input = {"query": tool_input_str[1:-1]}
-                else: # Assume raw string is the query
-                    tool_input = {"query": tool_input_str}
-            print(f"Agent decided to call tool (MANUALLY PARSED): web_search, Input: {tool_input}")
-            agent_outcome = AgentAction(
-                tool="duckduckgo_search", 
-                tool_input=tool_input, 
-                log=f"Manually Parsed from content: {search_match.group(0)}",
-                tool_call_id=manual_tool_call_id
-            )
-        elif download_match:
-            tool_input_str = download_match.group(1).strip()
-            if (tool_input_str.startswith("'") and tool_input_str.endswith("'")) or \
-               (tool_input_str.startswith('"') and tool_input_str.endswith('"')):
-               tool_input = tool_input_str[1:-1]
-            else:
-               tool_input = tool_input_str
-            print(f"Agent decided to call tool (MANUALLY PARSED): download_file, Input: {tool_input}")
-            agent_outcome = AgentAction(
-                tool="download_file", 
-                tool_input=tool_input, 
-                log=f"Manually Parsed from content: {download_match.group(0)}",
-                tool_call_id=manual_tool_call_id
-            )
+@tool
+def calculate(expression: str) -> str:
+    """
+    A tool that evaluates mathematical expressions safely.
+    
+    Args:
+        expression: A mathematical expression (e.g., '2 + 2 * 3').
+    """
+    try:
+        # Safe evaluation of mathematical expressions
+        allowed_chars = set('0123456789+-*/(). ')
+        if not all(c in allowed_chars for c in expression):
+            return "Error: Expression contains invalid characters"
         
-    # If still no agent_outcome (no tool call detected at all), create AgentFinish
-    if agent_outcome is None:
-        print(f"Agent decided to finish. Raw Content: {raw_content[:100]}...")
-        # --- Post-processing Workaround ---
-        marker = "<|im_start|>assistant"
-        marker_pos = raw_content.rfind(marker)
-        if marker_pos != -1:
-            final_content = raw_content[marker_pos + len(marker):].lstrip()
-            print(f"Stripped prompt echo for final answer. Using: {final_content[:100]}...")
-        else:
-            final_content = raw_content.strip()
-            print("Assistant marker not found for final answer. Using raw content.")
-        # --- End Workaround ---
-        agent_outcome = AgentFinish(return_values={"output": final_content}, log=raw_content)
-
-    # Add the original response (including potential tool calls) to history for context
-    new_history = state['chat_history'] + [response] 
-    return {"agent_outcome": agent_outcome, "chat_history": new_history}
-
-def tool_node(state: AgentState, tool_executor):
-    """Executes tools and returns the results, using a cache."""
-    print("Running tool_node")
-    agent_action = state['agent_outcome']
-    if not isinstance(agent_action, AgentAction):
-         print("Warning: tool_node called without AgentAction in state.")
-         return {}
-
-    # Construct a unique cache key for this tool call
-    tool_name = agent_action.tool
-    tool_input = str(agent_action.tool_input) # Ensure input is string for dict key
-    cache_key = f"{tool_name}::{tool_input}"
-    tool_cache = state.get('tool_cache', {})
-
-    # Check cache first
-    if cache_key in tool_cache:
-        observation = tool_cache[cache_key]
-        print(f"Cache hit for tool {tool_name} with input {tool_input[:50]}... Returning cached result.")
-    else:
-        print(f"Cache miss for tool {tool_name} with input {tool_input[:50]}... Executing tool.")
-        observation = tool_executor.invoke(agent_action)
-        print(f"Tool {tool_name} executed. Observation: {str(observation)[:200]}...")
-        # Update cache
-        tool_cache[cache_key] = str(observation)
-
-    new_intermediate_steps = state['intermediate_steps'] + [(agent_action, str(observation))]
-    # Directly use the tool_call_id from the AgentAction
-    # Assumes agent_action WILL have tool_call_id if it's an AgentAction leading here
-    tool_message = ToolMessage(
-        content=str(observation),
-        tool_call_id=agent_action.tool_call_id 
-    )
-    new_history = state['chat_history'] + [tool_message]
-
-    # Return updated state including the potentially modified cache
-    return {
-        "intermediate_steps": new_intermediate_steps,
-        "chat_history": new_history,
-        "tool_cache": tool_cache # Ensure cache updates are propagated
-    }
-
-def should_continue(state: AgentState) -> Literal["tools", "__end__"]:
-    """Determines whether to continue the loop or end."""
-    print("Running should_continue")
-    outcome = state['agent_outcome']
-    current_iter = state.get('current_iteration', 0)
-    max_iter = state.get('max_iterations', 10)
-
-    if isinstance(outcome, AgentFinish):
-        print("Decision: End (AgentFinish)")
-        return "__end__"
-    elif current_iter >= max_iter:
-        print("Decision: End (Max Iterations Reached)")
-        return "__end__"
-    elif isinstance(outcome, AgentAction):
-        print("Decision: Continue (Tools)")
-        return "tools"
-    else:
-        print("Decision: End (Unexpected State)")
-        return "__end__"
-
-# Add a dummy function decorated for the Spaces platform GPU check
-@spaces.GPU()
-def gpu_check():
-    """Dummy function to signal GPU usage to the Hugging Face Spaces platform."""
-    print("GPU check function called (decorator signals usage).")
-
-# --- Agent Definition ---
-class LangGraphAgent:
-    def __init__(self, max_iterations=10):
-        print("Initializing LangGraphAgent...")
-        self.max_iterations = max_iterations
-
-        # 1. Define LLM
-        print("Loading Hugging Face pipeline...")
-        try:
-            # Explicitly create the transformers pipeline first
-            hf_pipeline = pipeline(
-                "text-generation", # Task for instruct models
-                model="Qwen/Qwen2-72B-Instruct", # Use Qwen2 72B Instruct model
-                # Group model-specific args into model_kwargs
-                model_kwargs={"torch_dtype": "auto", "device_map": "auto"},
-                # Keep pipeline-specific args separate
-                max_new_tokens=1024,
-                add_special_tokens=False # Let ChatHuggingFace handle templating/special tokens
-            )
-            print("Hugging Face transformers pipeline loaded successfully.")
-            
-            # Wrap the transformers pipeline with LangChain's HuggingFacePipeline
-            print("Creating HuggingFacePipeline wrapper...")
-            lc_pipeline = HuggingFacePipeline(pipeline=hf_pipeline)
-            print("HuggingFacePipeline wrapper created successfully.")
-            
-            print("Initializing ChatHuggingFace wrapper...")
-            # Pass the LangChain pipeline wrapper to ChatHuggingFace
-            self.llm = ChatHuggingFace(llm=lc_pipeline)
-            # Pass the raw transformers pipeline directly to ChatHuggingFace
-            # self.llm = ChatHuggingFace(pipeline=hf_pipeline)
-            print("ChatHuggingFace wrapper initialized successfully.")
+        result = eval(expression)
+        return f"The result of {expression} is: {result}"
+    except Exception as e:
+        return f"Error evaluating expression: {str(e)}"
 
-        except Exception as e:
-            print(f"FATAL: Error loading Hugging Face pipeline or ChatHuggingFace: {e}")
-            raise
-
-        # 2. Define Tools
-        self.tools = agent_tools
-        # Use ToolNode 
-        self.tool_executor = ToolNode(self.tools)
-        print(f"Tools initialized: {[tool.name for tool in self.tools]}")
-
-        # 3. Create Prompt Template
-        self.prompt = ChatPromptTemplate.from_messages(
-            [
-                ("system", SYSTEM_PROMPT),
-                MessagesPlaceholder(variable_name="chat_history"),
-                ("human", "{input}"),
-            ]
-        )
-        print("Chat prompt template created.")
-
-        # Bind tools to the LLM
-        print("Binding tools to the LLM...")
-        self.llm_with_tools = self.llm.bind_tools(self.tools)
-        print("Tools bound successfully.")
-
-        # 4. Define Graph Nodes
-        agent_node_partial = partial(agent_node, llm_with_tools=self.llm_with_tools, prompt=self.prompt)
-        tool_node_partial = partial(tool_node, tool_executor=self.tool_executor)
-
-        # 5. Define Graph Structure
-        print("Defining LangGraph workflow...")
-        workflow = StateGraph(AgentState)
-        workflow.add_node("agent", agent_node_partial)
-        workflow.add_node("tools", tool_node_partial)
-        workflow.set_entry_point("agent")
-        workflow.add_conditional_edges(
-            "agent",
-            should_continue,
-            {"tools": "tools", "__end__": END},
-        )
-        workflow.add_edge("tools", "agent")
 
-        # 6. Compile Graph
-        print("Compiling LangGraph agent graph...")
-        try:
-            self.graph = workflow.compile()
-            print("LangGraph agent graph compiled successfully.")
-        except Exception as e:
-            print(f"FATAL: Error compiling LangGraph agent: {e}")
-            raise
-
-        print("LangGraphAgent initialized successfully.")
-
-    def __call__(self, question: str, task_id: str) -> str:
-        """Executes the agent graph for a given question and task ID."""
-        print(f"Agent invoked with question: '{question}' and task_id: '{task_id}'")
-        initial_state = AgentState(
-            question=question,
-            task_id=task_id,
-            intermediate_steps=[],
-            chat_history=[HumanMessage(content=question)],
-            downloaded_files={},
-            tool_cache={},  # Initialize the cache
-            error=None,
-            max_iterations=self.max_iterations,
-            current_iteration=0,
-            agent_outcome=None # Ensure agent_outcome is initialized
-        )
+@tool
+def search_web(query: str) -> str:
+    """
+    A tool that searches the web for information using DuckDuckGo.
+    
+    Args:
+        query: The search query string.
+    """
+    try:
+        from duckduckgo_search import DDGS
+        ddgs = DDGS()
+        results = list(ddgs.text(query, max_results=5))
+        
+        if not results:
+            return f"No results found for: {query}"
+        
+        output = f"Search results for '{query}':\n\n"
+        for i, result in enumerate(results, 1):
+            output += f"{i}. {result.get('title', 'N/A')}\n"
+            output += f"   {result.get('body', 'N/A')[:200]}...\n"
+            output += f"   URL: {result.get('href', 'N/A')}\n\n"
+        
+        return output
+    except Exception as e:
+        return f"Error searching web: {str(e)}"
 
-        final_state_result = None
-        try:
-            print(f"Invoking graph for task {task_id}...")
-            final_state_result = self.graph.invoke(
-                initial_state,
-                config={"recursion_limit": self.max_iterations + 10}
-            )
-            print(f"Graph invocation complete for task {task_id}.")
-
-            if final_state_result and isinstance(final_state_result.get('agent_outcome'), AgentFinish):
-                final_answer = final_state_result['agent_outcome'].return_values['output']
-                print(f"Agent finished successfully. Final Answer: {final_answer[:200]}...")
-                return final_answer
-            else:
-                error_msg = "Agent did not finish with a final answer (AgentFinish)."
-                print(f"{error_msg} Final State: {str(final_state_result)[:500]}")
-                last_message = "No message found in history."
-                if isinstance(final_state_result, dict) and 'chat_history' in final_state_result and final_state_result['chat_history']:
-                    last_message = final_state_result['chat_history'][-1].content
-                return f"AGENT_ERROR: {error_msg} Last Message: {last_message[:200]}..."
 
-        except Exception as e:
-            error_msg = f"Error during agent execution for task {task_id}: {e}"
-            print(error_msg)
-            if final_state_result:
-                error_msg += f" | Final State (partial): {str(final_state_result)[:500]}"
-            return f"AGENT_ERROR: {error_msg}"
-        finally:
-             print(f"--- Finished Agent Run for Task {task_id} ---")
-
-# --- Gradio App Logic ---
-# We need to make run_and_submit_all a generator to yield updates
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def create_agent(model_name: str = "llama3.2:3b-instruct-q4_K_M", 
+                 max_steps: int = 6,
+                 verbosity: int = 1) -> CodeAgent:
     """
-    Fetches all questions, runs the LangGraphAgent on them, submits all answers,
-    and displays the results. Yields status updates. Requires user login.
+    Create a CodeAgent with the specified model and tools
     """
-    space_id = os.getenv("SPACE_ID")
-    results_log = []
-    answers_payload = []
-    results_df = pd.DataFrame() # Initialize empty DataFrame
-    full_activity_log = "" # Initialize cumulative log
+    print(f"\nCreating agent with model: {model_name}")
+    print(f"Max steps: {max_steps}")
+    print(f"Verbosity: {verbosity}\n")
+    model = InferenceClientModel(
+    "Qwen/Qwen2.5-Coder-32B-Instruct", provider="together", max_tokens=8096)
+    
+    agent = CodeAgent(
+        model=model,
+        tools=[
+            get_current_time_in_timezone,
+            calculate,
+            search_web,
+            FinalAnswerTool()
+        ],
+        max_steps=max_steps,
+        verbosity_level=verbosity
+    )
+    
+    return agent
 
-    if not profile:
-        print("User not logged in.")
-        # Yield initial state with empty log
-        yield "Please Login to Hugging Face with the button to submit results.", "", results_df 
-        return # Stop execution if not logged in
+def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
-    username = profile.username
-    print(f"User logged in: {username}")
-    # Yield status update with empty log
-    yield f"User logged in: {username}. Initializing...", "", results_df 
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent
-    log_capture = io.StringIO()
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        initial_agent_log = "Initializing Agent...\n"
-        full_activity_log += initial_agent_log
-        yield initial_agent_log.strip(), full_activity_log, results_df
-        with contextlib.redirect_stdout(log_capture): # Capture prints during init
-            agent = LangGraphAgent(max_iterations=15)
-            print("Agent instantiation successful.") 
-        init_log_output = log_capture.getvalue()
-        full_activity_log += init_log_output
-        status_update = "Agent Initialized. Fetching questions..."
-        yield status_update, full_activity_log, results_df
+        agent = create_agent()
     except Exception as e:
-        error_msg = f"Error initializing agent: {e}"
-        print(error_msg)
-        full_activity_log += f"\nERROR: {error_msg}\n"
-        yield error_msg, full_activity_log, results_df
-        return
-    finally:
-        # Ensure any captured init log is added even if exception occurs later
-        init_log_output = log_capture.getvalue() 
-        if init_log_output not in full_activity_log: # Avoid duplication
-            full_activity_log += init_log_output
-
-    # Construct agent_code link
-    if space_id:
-        agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-        code_link_log = f"Agent code link: {agent_code}\n"
-        print(code_link_log.strip())
-        full_activity_log += code_link_log
-    else:
-        agent_code = "local_run_no_code_link"
-        code_link_log = "Warning: SPACE_ID not found. Using placeholder for agent_code link.\n"
-        print(code_link_log.strip())
-        full_activity_log += code_link_log
+        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
-    fetch_log_start = f"Fetching questions from: {questions_url}\n"
-    print(fetch_log_start.strip())
-    full_activity_log += fetch_log_start
-    questions_data = None
+    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:
-             empty_q_log = "Fetched questions list is empty or invalid format.\n"
-             print(empty_q_log.strip())
-             full_activity_log += empty_q_log
-             yield empty_q_log.strip(), full_activity_log, results_df
-             return
-        q_fetch_success = f"Fetched {len(questions_data)} questions.\n"
-        print(q_fetch_success.strip())
-        full_activity_log += q_fetch_success
-        status_update = f"Fetched {len(questions_data)} questions. Running agent..."
-        yield status_update, full_activity_log, results_df
+             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:
-        error_msg = f"Error fetching questions: {e}"
-        print(error_msg)
-        full_activity_log += f"\nERROR: {error_msg}\n"
-        yield error_msg, full_activity_log, results_df
-        return
-    except json.JSONDecodeError as e:
-         response_text = response.text if response else "No response object"
-         error_msg = f"Error decoding JSON response from questions endpoint: {e}"
-         print(error_msg)
-         print(f"Response text: {response_text[:500]}")
-         full_activity_log += f"\nERROR: {error_msg}\nResponse text: {response_text[:500]}\n"
-         yield f"Error decoding server response for questions: {e}", full_activity_log, results_df
-         return
+        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:
-        error_msg = f"An unexpected error occurred fetching questions: {e}"
-        print(error_msg)
-        full_activity_log += f"\nERROR: {error_msg}\n"
-        yield error_msg, full_activity_log, results_df
-        return
-
-    # 3. Run Agent on Questions
-    total_questions = len(questions_data)
-    run_start_log = f"Running agent on {total_questions} questions...\n"
-    print(run_start_log.strip())
-    full_activity_log += run_start_log
-    for i, item in enumerate(questions_data):
+        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")
-        
-        status_update = f"Running agent... Processing question {i+1}/{total_questions} (Task ID: {task_id})"
-        # Yield progress update with the current log
-        yield status_update, full_activity_log, pd.DataFrame(results_log)
-
         if not task_id or question_text is None:
-            skip_log = f"Skipping item with missing task_id or question: {item}\n"
-            print(skip_log.strip())
-            full_activity_log += skip_log
-            results_log.append({"Task ID": task_id or "Missing", "Question": question_text or "Missing", "Submitted Answer": "SKIPPED - Invalid item data"})
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
-
-        task_start_log = f"--- Running Task {task_id} ---\n"
-        print(task_start_log.strip())
-        full_activity_log += task_start_log
-        log_capture = io.StringIO() # Reset buffer for each agent call
         try:
-            with contextlib.redirect_stdout(log_capture): # Capture agent prints
-                submitted_answer = agent(question=question_text, task_id=task_id)
-                # Also capture the print right after the call if successful
-                print(f"Agent returned answer for task {task_id}: {submitted_answer[:100]}...\n")
-            
+            submitted_answer = agent(question_text)
             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})
         except Exception as e:
-             error_log = f"Error running agent on task {task_id}: {e}\n"
-             print(error_log.strip())
-             # Add error to main log even if not captured by redirect_stdout
-             if error_log not in log_capture.getvalue():
-                 full_activity_log += f"ERROR: {error_log}"
-             error_answer = f"AGENT_ERROR: {e}"
-             answers_payload.append({"task_id": task_id, "submitted_answer": error_answer})
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": error_answer})
-        finally:
-            # Always append the captured log for this task
-            current_task_log = log_capture.getvalue()
-            full_activity_log += current_task_log
-            task_end_log = f"--- Finished Task {task_id} ---\n\n"
-            print(task_end_log.strip())
-            full_activity_log += task_end_log
+             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:
-        no_answer_log = "Agent did not produce any answers to submit.\n"
-        print(no_answer_log.strip())
-        full_activity_log += no_answer_log
-        yield no_answer_log.strip(), full_activity_log, pd.DataFrame(results_log)
-        return
+        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 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished processing {total_questions} questions. Submitting {len(answers_payload)} answers for user '{username}'..."
-    prep_log = status_update + "\n"
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
-    full_activity_log += prep_log
-    results_df = pd.DataFrame(results_log) # Update DataFrame before final yield
-    yield status_update, full_activity_log, results_df
-
-    # 5. Submit Results
-    submit_start_log = f"Submitting {len(answers_payload)} answers to: {submit_url}\n"
-    print(submit_start_log.strip())
-    full_activity_log += submit_start_log
+
+    # 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()
@@ -658,85 +200,71 @@ 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.')}"
         )
-        submit_success_log = "Submission successful.\n"
-        print(submit_success_log.strip())
-        full_activity_log += submit_success_log
-        yield final_status, full_activity_log, results_df # Final status yield
+        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:
             error_json = e.response.json()
             error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
-        except json.JSONDecodeError:
+        except requests.exceptions.JSONDecodeError:
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
-        full_activity_log += f"\nERROR: {status_message}\n"
-        yield status_message, full_activity_log, results_df
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except requests.exceptions.Timeout:
         status_message = "Submission Failed: The request timed out."
         print(status_message)
-        full_activity_log += f"\nERROR: {status_message}\n"
-        yield status_message, full_activity_log, results_df
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except requests.exceptions.RequestException as e:
         status_message = f"Submission Failed: Network error - {e}"
         print(status_message)
-        full_activity_log += f"\nERROR: {status_message}\n"
-        yield status_message, full_activity_log, results_df
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
         status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
-        full_activity_log += f"\nERROR: {status_message}\n"
-        yield status_message, full_activity_log, results_df
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
 
-# --- Build Gradio Interface ---
+# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# LangGraph Agent Evaluation Runner")
-
-    # Updated instructions markdown reflecting current state
-    instructions_markdown = """
-**Welcome to the LangGraph Agent Evaluation Runner!**
-**What is this project?**
-This application is designed to test and evaluate an AI assistant (an "agent") built using the LangGraph framework and powered by the Llama 3 language model. The goal is to see how well this agent can answer a variety of questions, sometimes needing to use tools like web search or file downloading to find the right information.
-**How does this app work?**
-please log in using the Hugging Face login button below. We need your username to submit your agent's results.
-2.  **Run Evaluation:** Click the 'Run Evaluation & Submit All Answers' button.
-    *   The app will fetch a set of evaluation questions from a server.
-    *   For each question, the LangGraph agent will try to determine the best answer. It might use its built-in knowledge or decide to use a tool (like searching the web or reading a provided file).
-    *   Once the agent has processed all questions, the app will automatically submit all the answers linked to your username.
-3.  **See Results:** The final score and a table showing each question, the agent's answer, and whether it was correct will be displayed below. You'll also see status updates during the run.
-**Technical Details (for the curious):**
-*   **Agent Framework:** LangGraph (helps orchestrate the agent's steps)
-*   **Language Model:** `Qwen/Qwen2-72B-Instruct`
-*   **Tools Available to Agent:** DuckDuckGo Web Search, File Downloader
-*   **Key Feature:** The agent caches results from tools, so if it needs the same information again, it can retrieve it quickly without re-running the tool.
-**(Optional) For Developers:** You can clone this Space and modify the `app.py` file to experiment with different prompts, agent logic, or even different language models or tools.
-"""
-    gr.Markdown(instructions_markdown)
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        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:**
+        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.
+        """
+    )
 
     gr.LoginButton()
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=3, interactive=False) # Reduced lines slightly
-    agent_activity_feed = gr.Textbox(label="Agent Activity Log", lines=15, interactive=False, autoscroll=True)
+    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)
 
     run_button.click(
         fn=run_and_submit_all,
-        # The profile is implicitly available in the scope Gradio runs the function
-        outputs=[status_output, agent_activity_feed, results_table]
+        outputs=[status_output, results_table]
     )
 
-# --- Main Execution Block ---
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
-
-    # Call the GPU check function early during startup
-    gpu_check()
-
+    # 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}")
@@ -744,7 +272,7 @@ if __name__ == "__main__":
     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")
@@ -753,7 +281,5 @@ if __name__ == "__main__":
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for LangGraph Agent Evaluation...")
-    # Set share=False for security unless needed
-    # Set debug=True for more detailed logs during development
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)