Update app.py

app.py

@@ -2,122 +2,100 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-from smolagents import CodeAgent, HfApiModel, DuckDuckGoSearchTool
+from smolagents import CodeAgent, DuckDuckGoSearchTool
 
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+# --- Handle version changes in smolagents updates ---
+try:
+    from smolagents import InferenceClientModel as LLMModel
+except ImportError:
+    try:
+        from smolagents import HfApiModel as LLMModel
+    except ImportError:
+        from smolagents import LiteLLMModel as LLMModel
 
-class GenuineCourseAgent:
-    def __init__(self, hf_token):
-        print("Initializing genuine smolagents CodeAgent...")
-        
-        # 1. The Model: We use the powerful Qwen Coder model recommended by the course.
-        # Passing the hf_token ensures we do not get "401 Unauthorized" errors.
-        self.model = HfApiModel(
-            model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
-            token=hf_token
-        )
-        
-        # 2. The Agent & Tools: We equip the agent with web search so it can find real-time facts.
-        self.agent = CodeAgent(
-            tools=[DuckDuckGoSearchTool()], 
-            model=self.model,
-            add_base_tools=True,
-            max_steps=5 # Gives the agent enough room to search and reason
-        )
-        
-    def __call__(self, question: str) -> str:
-        # 3. The Prompt: GAIA requires EXACT string matches. 
-        # We must strictly prompt the agent to avoid conversational text.
-        prompt = (
-            f"You are an expert AI answering questions for the GAIA benchmark.\n"
-            f"Use the DuckDuckGo search tool to find factual information if needed.\n"
-            f"CRITICAL INSTRUCTION: Your final answer MUST be ONLY the exact value or string requested. "
-            f"Do NOT include any explanations, full sentences, or conversational text. "
-            f"If the answer is a list, separate items with a comma.\n\n"
-            f"Question: {question}"
-        )
-        try:
-            response = self.agent.run(prompt)
-            return str(response).strip()
-        except Exception as e:
-            print(f"Agent encountered an error: {e}")
-            return "Error during execution"
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-def run_and_submit_all(profile: gr.OAuthProfile | None, token: gr.OAuthToken | None):
-    space_id = os.getenv("SPACE_ID", "local") 
+def build_agent(hf_token):
+    # Using the course recommended model. 
+    # Passing the token ensures you don't get 401 Unauthorized errors.
+    model = LLMModel(
+        model_id="Qwen/Qwen2.5-Coder-32B-Instruct",
+        token=hf_token
+    )
     
-    if not profile or not token:
-        return "🚨 ERROR: Please click 'Sign in with Hugging Face' before running.", None
-    
-    username = profile.username
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+    agent = CodeAgent(
+        tools=[DuckDuckGoSearchTool()],
+        model=model,
+        add_base_tools=True,
+        max_steps=5
+    )
+    return agent
 
-    # Instantiate our real agent with the user's secure token
+def run_evaluation(profile: gr.OAuthProfile | None, oauth_token: gr.OAuthToken | None):
+    if not profile or not oauth_token:
+        return "🚨 ERROR: Please click 'Sign in with Hugging Face' first.", None
+        
+    space_id = os.getenv("SPACE_ID", "local")
+    
     try:
-        agent = GenuineCourseAgent(hf_token=token.token)
+        questions = requests.get(f"{DEFAULT_API_URL}/questions", timeout=15).json()
     except Exception as e:
-        return f"Failed to initialize agent: {e}", None
+        return f"Fetch Error: {e}", None
 
     try:
-        response = requests.get(questions_url, timeout=15)
-        response.raise_for_status()
-        questions_data = response.json()
+        agent = build_agent(oauth_token.token)
     except Exception as e:
-        return f"Error fetching questions: {e}", None
+        return f"Agent Initialization Error: {e}", None
 
-    results_log = []
-    answers_payload = []
+    payload = []
+    logs = []
     
-    print(f"Running agent on {len(questions_data)} questions. This will take time as the agent actively searches the web...")
+    print(f"Starting agent on {len(questions)} questions. This takes time as it actively searches the web...")
     
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
+    for q in questions:
+        task_id = q["task_id"]
+        question_text = q["question"]
+        
+        # We give the agent strict instructions so it formats the answer for the grader
+        prompt = (
+            f"Solve this task. You must output ONLY the exact final answer string. "
+            f"Do not include explanation, thinking, or full sentences. "
+            f"If the answer is a list, separate by commas.\n\nTask: {question_text}"
+        )
         
-        if not task_id or not question_text:
-            continue
+        try:
+            # The agent autonomously reasons and searches DuckDuckGo
+            ans = str(agent.run(prompt)).strip()
+        except Exception as e:
+            ans = "Execution Error"
             
-        # The agent natively attempts to solve the question
-        submitted_answer = agent(question_text)
+        payload.append({"task_id": task_id, "submitted_answer": ans})
+        logs.append({"Question": question_text[:60] + "...", "Answer": ans})
         
-        answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-        results_log.append({"Task ID": task_id, "Question": question_text[:60] + "...", "Answer": submitted_answer})
-
     submission_data = {
-        "username": username.strip(), 
-        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main", 
-        "answers": answers_payload
+        "username": profile.username.strip(),
+        "agent_code": f"https://huggingface.co/spaces/{space_id}/tree/main",
+        "answers": payload
     }
 
     try:
-        res = requests.post(submit_url, json=submission_data, timeout=120)
-        res.raise_for_status()
-        result_data = res.json()
-        score = result_data.get('score', 0)
-        
-        status = f"✅ Evaluation Complete!\nFinal Score: {score}%\n"
-        if score >= 30:
-            status += "🎉 REQUIREMENT PASSED. Please wait 45 minutes for the leaderboard to sync with the Certificate page."
-        else:
-            status += "⚠️ Score too low. The agent's searches may have missed the exact format."
-            
-        return status, pd.DataFrame(results_log)
+        res = requests.post(f"{DEFAULT_API_URL}/submit", json=submission_data, timeout=120).json()
+        score = res.get('score', 0)
+        status = f"✅ SUCCESS! Final Organic Score: {score}%\n\nIf your score is > 30%, wait 45 mins for the Certificate page to sync."
+        return status, pd.DataFrame(logs)
     except Exception as e:
-        return f"Submission Failed: {e}", pd.DataFrame(results_log)
+        return f"Submit Error: {e}", pd.DataFrame(logs)
 
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🤖 Official GAIA Agent Evaluator")
-    gr.Markdown("This app uses a genuine `smolagents.CodeAgent` with web search to legitimately solve the Unit 4 benchmark.")
+    gr.Markdown("# 🤖 Genuine GAIA Autonomous Agent")
+    gr.Markdown("This app uses a real `smolagents.CodeAgent` with a web search tool to legitimately solve the Unit 4 benchmark.")
     
     gr.LoginButton()
-    run_button = gr.Button("RUN REAL AGENT EVALUATION", variant="primary")
-    status_output = gr.Textbox(label="Status", lines=5)
-    results_table = gr.DataFrame(label="Agent Search Log", wrap=True)
+    btn = gr.Button("RUN AUTONOMOUS AGENT", variant="primary")
+    out_status = gr.Textbox(label="Status", lines=4)
+    out_table = gr.DataFrame(label="Submission Log")
     
-    run_button.click(fn=run_and_submit_all, inputs=None, outputs=[status_output, results_table])
+    btn.click(fn=run_evaluation, inputs=None, outputs=[out_status, out_table])
 
 if __name__ == "__main__":
     demo.launch()