Update app.py

app.py

@@ -1,310 +1,116 @@
+""" Basic Agent Evaluation Runner"""
 import os
-import re
+import inspect
 import gradio as gr
 import requests
 import pandas as pd
-from duckduckgo_search import DDGS
-from langchain_core.tools import tool
-from langchain_huggingface import HuggingFaceEndpoint, ChatHuggingFace
-from langgraph.prebuilt import create_react_agent
-from langgraph.graph import StateGraph
+from langchain_core.messages import HumanMessage
+from tools import build_graph
 
+
+
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Tools ---
-@tool
-def search_web(query: str) -> str:
-    """Search the web and return a relevant text snippet."""
-    try:
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=3))
-        if not results or not results[0].get("body"):
-            return "No result found"
-        return results[0]["body"]
-    except Exception as e:
-        return f"Web search failed: {e}"
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 
-@tool
-def run_code_snippet(code: str) -> str:
-    """Safely execute a Python code snippet and return its result."""
-    try:
-        local_env = {}
-        exec(code, {}, local_env)
-        result = [v for v in local_env.values() if isinstance(v, (int, float, str))]
-        return str(result[0]) if result else "0"
-    except Exception as e:
-        return f"Error in code: {str(e)}"
 
-# --- GAIA Agent via LangGraph ---
-class LangGraphGAIAAgent:
+class BasicAgent:
+    """A langgraph agent."""
     def __init__(self):
-        print("[LangGraph Agent] Initializing Hugging Face LLM...")
-
-        # Use a Hugging Face model that supports tool calling
-        hf_token = os.getenv("agents_token")
-        if not hf_token:
-            raise ValueError("agents_token is required. Please set it in your Space secrets.")
-
-        try:
-            # Try models that are more likely to work with HuggingFaceEndpoint
-            model_options = [
-                
-                "mistralai/Mistral-7B-Instruct-v0.3",
-                "meta-llama/Llama-3.1-8B-Instruct",
-                "openai-community/gpt2",
-            ]
-
-            llm = None
-            for model_name in model_options:
-                try:
-                    print(f"Trying model: {model_name}")
-                    endpoint = HuggingFaceEndpoint(
-                        repo_id=model_name,
-                        temperature=0.1,
-                        huggingfacehub_api_token=hf_token
-                    )
-                    # Test the endpoint with a simple call
-                    test_response = endpoint.invoke("Hello")
-                    print(f"Test successful for {model_name}")
-
-                    # Wrap with ChatHuggingFace for better compatibility
-                    llm = ChatHuggingFace(llm=endpoint)
-                    print(f"Successfully initialized: {model_name}")
-                    break
-                except Exception as e:
-                    print(f"Failed to initialize {model_name}: {e}")
-                    continue
-
-            if llm is None:
-                raise ValueError("Failed to initialize any Hugging Face model")
-
-        except Exception as e:
-            print(f"Error with HF models: {e}")
-            raise
-
-        print("[LangGraph Agent] Creating ReAct loop...")
-        try:
-            self.graph = create_react_agent(llm, [search_web, run_code_snippet])
-            print("Successfully created ReAct agent with tools")
-        except Exception as e:
-            print(f"Error creating ReAct agent with tools: {e}")
-            # Always use fallback since HF models often have issues with ReAct
-            print("Using fallback agent with manual tool integration...")
-            self._create_fallback_agent(llm, [search_web, run_code_snippet])
-
-    def _create_fallback_agent(self, llm, tools):
-        """Create a robust fallback agent that manually handles tools"""
-        from langgraph.graph import StateGraph, END
-        from typing import Dict, Any
-
-        def agent_node(state: Dict[str, Any]) -> Dict[str, Any]:
-            messages = state.get("messages", [])
-            if not messages:
-                return {"messages": [{"role": "assistant", "content": "No input provided"}]}
-
-            user_message = messages[-1].get("content", "")
-            print(f"Processing: {user_message[:100]}...")
-
-            try:
-                # Analyze the question and decide which tool to use
-                response = self._process_question_with_tools(user_message)
-                return {"messages": [{"role": "assistant", "content": response}]}
-            except Exception as e:
-                print(f"Error in agent node: {e}")
-                return {"messages": [{"role": "assistant", "content": f"Error processing question: {str(e)}"}]}
-
-        # Create a simple state graph
-        workflow = StateGraph(dict)
-        workflow.add_node("agent", agent_node)
-        workflow.set_entry_point("agent")
-        workflow.add_edge("agent", END)
-        self.graph = workflow.compile()
-
-    def _process_question_with_tools(self, question: str) -> str:
-        """Process question using appropriate tools"""
-        question_lower = question.lower()
-
-        # Check if we need web search
-        search_keywords = ["wikipedia", "who", "what", "when", "where", "how many", "albums", "species", "articles"]
-        needs_search = any(keyword in question_lower for keyword in search_keywords)
-
-        # Check if we need code execution
-        code_keywords = ["calculate", "compute", "count", "number", "highest", "lowest"]
-        needs_code = any(keyword in question_lower for keyword in code_keywords)
-
-        result_parts = []
-
-        if needs_search:
-            try:
-                # Extract key terms for search
-                search_query = self._extract_search_terms(question)
-                print(f"Searching for: {search_query}")
-                search_result = search_web.invoke({"query": search_query})
-                result_parts.append(f"Search result: {search_result}")
-            except Exception as e:
-                result_parts.append(f"Search failed: {e}")
-
-        if needs_code and ("count" in question_lower or "number" in question_lower):
-            try:
-                # Try to generate relevant code
-                code = self._generate_counting_code(question)
-                if code:
-                    print(f"Executing code: {code}")
-                    code_result = run_code_snippet.invoke({"code": code})
-                    result_parts.append(f"Calculation: {code_result}")
-            except Exception as e:
-                result_parts.append(f"Code execution failed: {e}")
-
-        # Combine results and generate final answer
-        if result_parts:
-            combined_info = " | ".join(result_parts)
-            try:
-                # Use the LLM to synthesize the final answer
-                prompt = f"Based on this information: {combined_info}\n\nAnswer the question: {question}\n\nProvide a direct, concise answer:"
-                llm_response = llm.invoke(prompt)
-                if hasattr(llm_response, 'content'):
-                    return llm_response.content
-                else:
-                    return str(llm_response)
-            except Exception as e:
-                return combined_info  # Return raw info if LLM fails
-        else:
-            # Direct LLM response for simple questions
-            try:
-                response = llm.invoke(f"Answer this question concisely: {question}")
-                if hasattr(response, 'content'):
-                    return response.content
-                else:
-                    return str(response)
-            except Exception as e:
-                return f"Unable to process question: {str(e)}"
-
-    def _extract_search_terms(self, question: str) -> str:
-        """Extract relevant search terms from the question"""
-        # Remove common question words and extract key terms
-        import re
-
-        # Handle reverse text (like the third question)
-        if question.count(' ') > 3 and question.endswith('fI'):
-            # This might be reversed text
-            reversed_q = question[::-1]
-            if "If you understand" in reversed_q:
-                return "word opposite left"
-
-        # Extract key entities and terms
-        key_terms = []
-
-        # Look for quoted terms, names, dates, numbers
-        quoted_terms = re.findall(r'"([^"]*)"', question)
-        key_terms.extend(quoted_terms)
-
-        # Look for proper nouns (capitalized words)
-        proper_nouns = re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', question)
-        key_terms.extend(proper_nouns)
-
-        # Look for years/dates
-        years = re.findall(r'\b(19|20)\d{2}\b', question)
-        key_terms.extend(years)
-
-        # Look for specific terms
-        specific_terms = ["albums", "species", "dinosaur", "wikipedia", "featured article"]
-        for term in specific_terms:
-            if term in question.lower():
-                key_terms.append(term)
-
-        return " ".join(key_terms[:5])  # Limit to 5 terms
-
-    def _generate_counting_code(self, question: str) -> str:
-        """Generate simple counting code based on the question"""
-        if "between" in question.lower() and any(year in question for year in ["2000", "2009"]):
-            return """
-# Count years between 2000 and 2009 (inclusive)
-start_year = 2000
-end_year = 2009
-years_in_range = list(range(start_year, end_year + 1))
-count = len(years_in_range)
-print(f"Years from {start_year} to {end_year}: {count} years")
-count
-"""
-        return None
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
 
     def __call__(self, question: str) -> str:
-        try:
-            print(f"[LangGraph Agent] Running on: {question}")
-            result = self.graph.invoke({"messages": [{"role": "user", "content": question}]})
-
-            # Handle different response formats
-            if isinstance(result, dict):
-                if "messages" in result and result["messages"]:
-                    output = result["messages"][-1].get("content", "")
-                else:
-                    output = result.get("output", str(result))
-            else:
-                output = str(result)
-
-            if not output:
-                raise ValueError("Model produced no output")
-            return f"FINAL ANSWER: {self.clean(output)}"
-        except Exception as e:
-            print(f"[LangGraph Agent] Error: {e}")
-            return f"FINAL ANSWER: Error: {e}"
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
+
+
+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
 
-    def clean(self, text: str) -> str:
-        return re.sub(r"[\$,%]", "", text).strip()
-
-# --- Evaluation & Submission Pipeline ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
-    space_id = os.getenv("SPACE_ID")
     if profile:
-        username = f"{profile.username}"
+        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 ( modify this part to create your agent)
     try:
-        agent = LangGraphGAIAAgent()
+        agent = BasicAgent()
     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:
-            return "Fetched questions list is empty or invalid format.", None
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
-    except Exception as e:
+    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")
         if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
-
         try:
             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:
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {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:
+        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. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
 
+    # 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()
@@ -316,33 +122,59 @@ 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.')}"
         )
-        return 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:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
 
-# --- Gradio UI ---
-with gr.Blocks() as demo:
-    gr.Markdown("# GAIA Agent Evaluation Runner (LangGraph Edition)")
-    gr.Markdown("""
-    **Instructions:**
-    1. Set your Hugging Face token in the Space Settings → Secrets as `HUGGINGFACEHUB_API_TOKEN`.
-    2. Log in to Hugging Face below to associate your username.
-    3. Run the agent to fetch, answer, and submit GAIA benchmark questions.
 
-    **Note**: The agent will try multiple HF models and fall back to manual tool usage if needed.
-    """)
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    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()
 
-    gr.Markdown("## 🔍 Try a Question Preview")
-    preview_input = gr.Textbox(label="Your GAIA-style question")
-    preview_output = gr.Textbox(label="Agent's Response", lines=2)
-    preview_button = gr.Button("Preview Answer")
-
-    preview_button.click(lambda q: LangGraphGAIAAgent()(q), inputs=preview_input, outputs=preview_output)
-
     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)
 
     run_button.click(
@@ -350,25 +182,26 @@ with gr.Blocks() as demo:
         outputs=[status_output, results_table]
     )
 
-# --- Main Entry ---
 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: https://{space_host_startup}.hf.space")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
-        print("ℹ️  SPACE_HOST not set.")
+        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: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   Code: 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 not set.")
+        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 GAIA Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)