Update app.py

app.py

@@ -10,18 +10,15 @@ import torch
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Enhanced BasicAgent (local model version) ---
+# --- Local LLM Agent ---
 class BasicAgent:
     """
     Loads and runs a small LLM *locally* inside the Hugging Face Space
-    instead of calling the Hugging Face Inference API (which is blocked).
+    instead of calling an external inference API.
     """
     def __init__(self):
-        # ✅ Small model to fit free Spaces — change to another instruct model if needed
         model_id = "HuggingFaceTB/SmolLM2-1.7B-Instruct"
         print(f"🚀 Loading model locally: {model_id}")
-        
-        # Load tokenizer and model
         self.tokenizer = AutoTokenizer.from_pretrained(model_id)
         self.model = AutoModelForCausalLM.from_pretrained(
             model_id,
@@ -31,73 +28,79 @@ class BasicAgent:
         print("✅ Local model ready.")
 
     def _clean(self, raw: str) -> str:
-        """Post-process the model output to a short, exact value."""
+        """Cleans raw model output for exact-match submission."""
         txt = raw.strip()
-        lines = [l.strip() for l in txt.splitlines() if l.strip()]
-        if lines:
-            txt = lines[-1]
-        txt = re.sub(r"^(final answer|answer|prediction)\s*[:\-]\s*", "", txt, flags=re.I)
+        # remove “FINAL ANSWER:” or similar
+        txt = re.sub(r"(?i)final\s*answer\s*[:\-]*", "", txt)
+        txt = re.sub(r"^(answer|prediction)\s*[:\-]*", "", txt, flags=re.I)
         txt = txt.strip("`'\" \t\n\r")
         txt = re.sub(r"[ \t]*[.;,:-]+$", "", txt)
         return txt[:200]
 
     def __call__(self, question: str) -> str:
-        print(f"🧠 Agent received question: {question[:120]}...")
-        
-        # Simple concise prompt
+        print(f"🧠 Question: {question[:100]}...")
+        # system-style prompt based on GAIA paper instructions
         prompt = textwrap.dedent(f"""
-        You must answer the question with a single, concise value
-        (number, word, date, or short phrase) and nothing else.
-        
+        You are a general AI assistant. I will ask you a question. 
+        Report your thoughts, and finish your answer with the following template: 
+        FINAL ANSWER: [YOUR FINAL ANSWER].
+        YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.
+        If you are asked for a number, don't use commas or units.
+        If you are asked for a string, don't use articles or abbreviations.
+        If you are asked for a list, follow the above format for each item.
+
         Question: {question}
-        Final answer:
         """).strip()
-        
+
         inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
-        
-        # Generate
         with torch.no_grad():
             outputs = self.model.generate(
                 **inputs,
-                max_new_tokens=50,
+                max_new_tokens=80,
                 temperature=0.7,
                 do_sample=True,
                 pad_token_id=self.tokenizer.eos_token_id,
             )
-        
+
         generated_ids = outputs[0][inputs["input_ids"].shape[1]:]
         raw_answer = self.tokenizer.decode(generated_ids, skip_special_tokens=True)
         clean_ans = self._clean(raw_answer)
-        print(f"💡 Agent raw: '{raw_answer[:80]}' → clean: '{clean_ans}'")
+        print(f"💡 Raw: '{raw_answer[:80]}' → Clean: '{clean_ans}'")
         return clean_ans
 
 
-# --- Test Questions & Expected Answers ---
-QUESTIONS_AND_ANSWERS = [
-    {"question": "What is the capital of France?", "expected": "Paris"},
-    {"question": "What is 5 + 7?", "expected": "12"},
-    {"question": "In what year did World War II end?", "expected": "1945"},
-    {"question": "What is the largest planet in our solar system?", "expected": "Jupiter"},
-    {"question": "Who wrote 'Romeo and Juliet'?", "expected": "Shakespeare"},
-]
+# --- Fetch Questions ---
+def fetch_questions() -> list[dict]:
+    """Fetch all evaluation questions via GET /questions."""
+    try:
+        resp = requests.get(f"{DEFAULT_API_URL}/questions", timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+        if isinstance(data, list):
+            print(f"✅ Retrieved {len(data)} questions from API.")
+            return data
+        else:
+            print("⚠️ Unexpected response format from /questions.")
+            return []
+    except Exception as e:
+        print(f"❌ Failed to fetch questions: {e}")
+        return []
 
 
-# --- Submission Function ---
-def submit_answers(answers: list, token: str) -> dict:
+# --- Submit Answers ---
+def submit_answers(username: str, code_link: str, answers: list[dict], token: str) -> dict:
     """
-    Submit answers to the scoring API.
+    Submit answers to POST /submit for scoring.
+    Each answer must include task_id and submitted_answer.
     """
+    payload = {
+        "username": username,
+        "agent_code": code_link,
+        "answers": answers,
+    }
+
+    headers = {"Authorization": f"Bearer {token}"} if token else {}
     try:
-        space_host = os.getenv("SPACE_HOST", "")
-        space_id = os.getenv("SPACE_ID", "")
-        
-        payload = {
-            "answers": answers,
-            "space_host": space_host,
-            "space_id": space_id,
-        }
-        
-        headers = {"Authorization": f"Bearer {token}"}
         resp = requests.post(
             f"{DEFAULT_API_URL}/submit",
             json=payload,
@@ -105,76 +108,101 @@ def submit_answers(answers: list, token: str) -> dict:
             timeout=60,
         )
         resp.raise_for_status()
+        print("✅ Submission successful.")
         return resp.json()
     except Exception as e:
+        print(f"❌ Submission error: {e}")
         return {"success": False, "message": str(e)}
 
 
-# --- Main Run Function (fixed for HF_TOKEN) ---
+# --- Main Run Function (using HF_TOKEN) ---
 def run_and_submit_all(profile: gr.OAuthProfile | None = None, *_):
     """
-    Runs the local agent and submits answers.
-    Uses HF_TOKEN from environment variables instead of Gradio OAuth token.
+    Full pipeline:
+    1. Fetch questions
+    2. Run local agent
+    3. Submit answers via API
     """
-    # --- Step 1: Detect user login ---
-    if profile and hasattr(profile, "name"):
-        print(f"👤 Logged in as: {profile.name}")
+    # Step 1: Identify user
+    username = profile.name if profile and hasattr(profile, "name") else os.getenv("HF_USERNAME", "")
+    if username:
+        print(f"👤 Running as: {username}")
     else:
-        print("⚠️ No OAuth profile detected (this is fine if HF_TOKEN is set).")
+        print("⚠️ Username not detected — please log in via Hugging Face.")
+        username = "anonymous"
 
-    # --- Step 2: Get token from environment variable ---
+    # Step 2: Load token from environment
     token = os.getenv("HF_TOKEN")
     if not token:
         return (
-            "❌ No token found. Please set your Hugging Face token as an environment variable named `HF_TOKEN`.\n"
-            "In your Space: Settings → Repository secrets → Add new secret → Name: HF_TOKEN, Value: your_token_here",
+            "❌ No token found. Please add a secret named `HF_TOKEN` in your Space settings.",
             pd.DataFrame(),
         )
 
-    # --- Step 3: Instantiate the agent ---
+    # Step 3: Load code link (required for submission)
+    space_id = os.getenv("SPACE_ID", "")
+    code_link = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "N/A"
+
+    # Step 4: Fetch questions
+    questions = fetch_questions()
+    if not questions:
+        return "❌ Could not fetch questions from API.", pd.DataFrame()
+
+    # Step 5: Instantiate model
     try:
         agent = BasicAgent()
     except Exception as e:
         return f"❌ Error instantiating agent: {e}", pd.DataFrame()
 
-    # --- Step 4: Collect answers ---
+    # Step 6: Answer questions
     results = []
-    for qa in QUESTIONS_AND_ANSWERS:
-        q = qa["question"]
-        expected = qa["expected"]
+    for q in questions:
+        task_id = q.get("task_id")
+        question_text = q.get("question", "")
         try:
-            answer = agent(q)
+            answer = agent(question_text)
         except Exception as e:
             answer = f"[Error: {e}]"
-        results.append({"question": q, "answer": answer, "expected": expected})
+        results.append({
+            "task_id": task_id,
+            "question": question_text,
+            "submitted_answer": answer
+        })
 
-    # --- Step 5: Build DataFrame ---
     df = pd.DataFrame(results)
 
-    # --- Step 6: Submit ---
-    answers_list = [r["answer"] for r in results]
-    submission_result = submit_answers(answers_list, token)
+    # Step 7: Submit to API
+    submission_payload = [
+        {"task_id": r["task_id"], "submitted_answer": r["submitted_answer"]}
+        for r in results
+    ]
+    result = submit_answers(username, code_link, submission_payload, token)
+
+    message = result.get("message", "No message returned.")
+    score = result.get("score")
+    if score is not None:
+        message += f" | Score: {score:.2%}"
 
-    if submission_result.get("success"):
-        msg = submission_result.get("message", "✅ Submission successful")
-        return f"✅ {msg}", df
+    if result.get("success", True):
+        return f"✅ Submission successful: {message}", df
     else:
-        msg = submission_result.get("message", "Unknown error")
-        return f"❌ Submission failed: {msg}", df
+        return f"❌ Submission failed: {message}", df
 
 
 # --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# 🧠 Basic Agent Evaluation Runner")
+    gr.Markdown("# 🧠 Unit 4 Agent Evaluation Runner")
     gr.Markdown(
         """
-        **Instructions:**
-        1. Log in to your Hugging Face account.
-        2. Add your Hugging Face token as a secret named `HF_TOKEN` in your Space settings.
+        ### Instructions
+        1. Log in with your Hugging Face account.
+        2. Add your HF token as a secret (`HF_TOKEN`) in your Space → Settings → Repository Secrets.
         3. Click **Run Evaluation & Submit All Answers**.
 
         ---
-        The agent now runs *locally* inside the Space instead of using the API.
+        The agent runs *locally* and uses the official API routes:
+        - `GET /questions`
+        - `POST /submit`
         """
     )
     login_button = gr.LoginButton()
@@ -189,26 +217,24 @@ with gr.Blocks() as demo:
     )
 
 
-# --- Launch ---
+# --- Launch App ---
 if __name__ == "__main__":
     print("\n" + "-" * 30 + " App Starting " + "-" * 30)
-    
     space_host = os.getenv("SPACE_HOST")
     space_id = os.getenv("SPACE_ID")
-    
+
     if space_host:
-        print(f"✅ SPACE_HOST found: {space_host}")
-        print(f"   Runtime URL should be: https://{space_host}.hf.space")
+        print(f"✅ SPACE_HOST: {space_host}")
+        print(f"   Runtime URL: https://{space_host}.hf.space")
     else:
-        print("ℹ️  SPACE_HOST not found (running locally?).")
-    
+        print("ℹ️ No SPACE_HOST (running locally?)")
+
     if space_id:
-        print(f"✅ SPACE_ID found: {space_id}")
-        print(f"   Repo URL: https://huggingface.co/spaces/{space_id}")
-        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id}/tree/main")
+        print(f"✅ SPACE_ID: {space_id}")
+        print(f"   Repo: https://huggingface.co/spaces/{space_id}/tree/main")
     else:
-        print("ℹ️  SPACE_ID not found (running locally?).")
-    
-    print("-" * (60 + len(" App Starting ")) + "\n")
+        print("ℹ️ No SPACE_ID (running locally?)")
+
+    print("-" * (60 + len(' App Starting ')) + "\n")
     print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)