Restore single-button UI and refine answer formatting

agent.py

@@ -1,10 +1,11 @@
 import asyncio
 import os
 import re
+import time
 from pathlib import Path
 from threading import Thread
 from typing import Any
-from urllib.parse import quote_plus, urlparse, parse_qs
+from urllib.parse import urlparse, parse_qs
 
 import requests
 
@@ -34,9 +35,14 @@ or the phrase "FINAL ANSWER". The scoring is exact match, so be concise:
 - If the answer is a name, title, date, URL, or short phrase, return only that.
 - Preserve capitalization only when it matters for the answer.
 - If the question asks for a comma-separated list, use that format exactly.
+- Do not add a period or any other punctuation at the end unless it is explicitly part of the answer.
 """
 
 
+def log(message: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {message}", flush=True)
+
+
 def _read_text_file(path: Path) -> str:
     for encoding in ("utf-8", "utf-8-sig", "latin-1"):
         try:
@@ -92,10 +98,12 @@ def _summarize_pdf(path: Path) -> str:
 
 def summarize_attachment(file_path: str | None, file_name: str | None) -> str:
     if not file_path:
+        log("Attachment tool: no attachment.")
         return "No attachment."
 
     path = Path(file_path)
     suffix = path.suffix.lower()
+    log(f"Attachment tool: reading {file_name or path.name} ({suffix or 'no extension'}).")
 
     try:
         if suffix in {".txt", ".md", ".json", ".html", ".xml", ".py", ".csv"}:
@@ -153,6 +161,7 @@ def _get_youtube_context(question: str) -> str:
     if not video_id:
         return ""
 
+    log(f"YouTube tool: fetching transcript for {video_id}.")
     try:
         from youtube_transcript_api import YouTubeTranscriptApi
     except ImportError:
@@ -164,6 +173,7 @@ def _get_youtube_context(question: str) -> str:
         else:
             transcript = YouTubeTranscriptApi().fetch(video_id, languages=["en", "en-US"])
     except Exception as exc:
+        log(f"YouTube tool: failed for {video_id}: {exc}")
         return f"YouTube tool: could not fetch transcript for {video_id}: {exc}"
 
     lines = []
@@ -177,10 +187,12 @@ def _get_youtube_context(question: str) -> str:
         text = text.replace("\n", " ").strip()
         if text:
             lines.append(f"[{start:.1f}s] {text}")
+    log(f"YouTube tool: transcript fetched with {len(lines)} line(s).")
     return "YouTube transcript:\n" + "\n".join(lines)
 
 
 def _wiki_api_get(params: dict) -> dict:
+    log(f"Wikipedia tool: API request {params.get('action')} {params.get('list') or params.get('prop')}.")
     response = requests.get(
         "https://en.wikipedia.org/w/api.php",
         params={"format": "json", "formatversion": "2", **params},
@@ -236,6 +248,7 @@ def _get_wikipedia_context(question: str) -> str:
     if not any(token in lowered for token in ["wikipedia", "featured article", "dinosaur"]):
         return ""
 
+    log("Wikipedia tool: gathering context.")
     queries = [(question, "0")]
     if "featured article" in lowered and "dinosaur" in lowered:
         queries.extend(
@@ -251,8 +264,10 @@ def _get_wikipedia_context(question: str) -> str:
     seen_titles = set()
     for query, namespace in queries[:6]:
         try:
+            log(f"Wikipedia tool: searching namespace {namespace}: {query}")
             search_results = _wiki_search(query, namespace=namespace, limit="7")
         except Exception as exc:
+            log(f"Wikipedia tool: search failed: {exc}")
             parts.append(f"Wikipedia search failed for {query!r}: {exc}")
             continue
 
@@ -282,10 +297,12 @@ def _get_wikipedia_context(question: str) -> str:
     )
     for title in ordered_titles[:4]:
         try:
+            log(f"Wikipedia tool: fetching page text for {title}.")
             page_text = _wiki_page_text(title)
             if page_text:
                 parts.append(f"\nPage text: {title}\n{page_text[:3000]}")
         except Exception as exc:
+            log(f"Wikipedia tool: page fetch failed for {title}: {exc}")
             parts.append(f"Could not fetch page {title!r}: {exc}")
 
     if "featured article" in lowered and "dinosaur" in lowered:
@@ -322,6 +339,7 @@ def _needs_web_context(question: str) -> bool:
 
 
 def _web_search(query: str, max_results: int = 5) -> list[dict]:
+    log(f"Web tool: searching: {query}")
     try:
         from ddgs import DDGS
     except ImportError:
@@ -339,7 +357,9 @@ def _web_search(query: str, max_results: int = 5) -> list[dict]:
                     }
                 )
     except Exception as exc:
+        log(f"Web tool: search failed: {exc}")
         return [{"title": "Web search failed", "href": "", "body": str(exc)}]
+    log(f"Web tool: got {len(results)} result(s).")
     return results
 
 
@@ -347,10 +367,12 @@ def _extract_page_text(url: str, max_chars: int = 5000) -> str:
     if not url.startswith(("http://", "https://")):
         return ""
 
+    log(f"Web tool: fetching page: {url}")
     try:
         response = requests.get(url, headers={"User-Agent": USER_AGENT}, timeout=20)
         response.raise_for_status()
     except Exception as exc:
+        log(f"Web tool: fetch failed for {url}: {exc}")
         return f"Could not fetch {url}: {exc}"
 
     content_type = response.headers.get("content-type", "").lower()
@@ -369,6 +391,7 @@ def _extract_page_text(url: str, max_chars: int = 5000) -> str:
 
     title = soup.get_text(" ", strip=True)
     title = re.sub(r"\s+", " ", title)
+    log(f"Web tool: extracted {min(len(title), max_chars)} char(s) from page.")
     return title[:max_chars]
 
 
@@ -376,6 +399,7 @@ def _get_web_context(question: str) -> str:
     if not _needs_web_context(question):
         return ""
 
+    log("Web tool: gathering general web context.")
     queries = [question]
     lowered = question.lower()
     if "libretext" in lowered or "libretexts" in lowered or "ck-12" in lowered:
@@ -413,6 +437,7 @@ def _get_web_context(question: str) -> str:
 
 
 def gather_tool_context(question: str) -> str:
+    log("Tools: gathering external context.")
     contexts = []
     youtube_context = _get_youtube_context(question)
     if youtube_context:
@@ -427,7 +452,9 @@ def gather_tool_context(question: str) -> str:
         contexts.append(web_context)
 
     combined = "\n\n".join(contexts).strip()
+    log(f"Tools: combined context length {len(combined)} char(s).")
     if len(combined) > MAX_TOOL_CHARS:
+        log(f"Tools: truncating context to {MAX_TOOL_CHARS} char(s).")
         return combined[:MAX_TOOL_CHARS] + "\n\n[Tool context truncated.]"
     return combined or "No external tool context."
 
@@ -446,6 +473,8 @@ def clean_final_answer(raw_answer: str) -> str:
 
     if (answer.startswith('"') and answer.endswith('"')) or (answer.startswith("'") and answer.endswith("'")):
         answer = answer[1:-1].strip()
+    if len(answer) > 1 and answer.endswith(".") and not re.search(r"\d\.$", answer):
+        answer = answer[:-1].strip()
     return answer
 
 
@@ -531,7 +560,7 @@ class BasicAgent:
             "base_url": OPENROUTER_BASE_URL,
         }
         self.model = model
-        print(f"BasicAgent initialized with OpenRouter model: {self.model}")
+        log(f"BasicAgent initialized with OpenRouter model: {self.model}")
 
     def _new_agent(self):
         # Build a fresh client per task. Reusing the async client across Gradio's
@@ -554,6 +583,7 @@ class BasicAgent:
         file_path: str | None = None,
         file_name: str | None = None,
     ) -> str:
+        log(f"Agent: starting task {task_id or 'unknown'}.")
         attachment_context = summarize_attachment(file_path, file_name)
         tool_context = gather_tool_context(question)
         prompt = f"""
@@ -571,5 +601,8 @@ External tool context:
 Return only the exact final answer.
 """
 
+        log(f"Agent: calling OpenRouter model for task {task_id or 'unknown'}.")
         result = _run_coro_sync(self._new_agent().run(prompt))
-        return clean_final_answer(_result_to_text(result))
+        answer = clean_final_answer(_result_to_text(result))
+        log(f"Agent: completed task {task_id or 'unknown'} -> {answer}")
+        return answer

app.py

@@ -1,5 +1,6 @@
 import json
 import os
+import time
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from urllib.parse import quote
@@ -28,6 +29,10 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 CACHE_PATH = Path("answers_cache.json")
 
 
+def log(message: str) -> None:
+    print(f"[{time.strftime('%H:%M:%S')}] {message}", flush=True)
+
+
 if spaces:
     @spaces.GPU(duration=1)
     def dummy_gpu():
@@ -49,6 +54,7 @@ def save_cache(cache: dict) -> None:
 
 def fetch_questions(api_url: str) -> list[dict]:
     questions_url = f"{api_url}/questions"
+    log(f"Fetching questions from {questions_url}")
     response = requests.get(questions_url, timeout=30)
     response.raise_for_status()
     questions = response.json()
@@ -69,14 +75,17 @@ def download_attachment(item: dict, api_url: str, temp_dir: str) -> tuple[str |
     file_url = f"{api_url}/files/{encoded_task_id}"
 
     try:
+        log(f"Downloading attachment for task {task_id}: {safe_name}")
         response = requests.get(file_url, timeout=60)
         response.raise_for_status()
     except requests.exceptions.HTTPError as exc:
         if exc.response is not None and exc.response.status_code == 404:
+            log(f"Attachment 404 for task {task_id}: {safe_name}")
             return None, f"Attachment listed as {safe_name}, but the scoring API returned 404 for {file_url}."
         raise
 
     attachment_path.write_bytes(response.content)
+    log(f"Attachment saved for task {task_id}: {attachment_path}")
     return str(attachment_path), None
 
 
@@ -87,6 +96,15 @@ def rows_to_dataframe(rows: list[dict]) -> pd.DataFrame:
     )
 
 
+def cache_to_payload(cache: dict) -> list[dict]:
+    payload = []
+    for task_id, item in cache.items():
+        submitted_answer = item.get("submitted_answer")
+        if submitted_answer and not str(submitted_answer).startswith("AGENT ERROR:"):
+            payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+    return payload
+
+
 def run_agent(profile: gr.OAuthProfile | None, run_all_questions: bool, use_cache: bool):
     if not profile:
         return "Please log in to Hugging Face first.", [], rows_to_dataframe([])
@@ -129,10 +147,12 @@ def run_agent(profile: gr.OAuthProfile | None, run_all_questions: bool, use_cach
                 continue
 
             cache_key = str(task_id)
+            log(f"Task {index}/{len(questions_data)} started: {task_id}")
             if use_cache and cache_key in cache:
                 submitted_answer = cache[cache_key]["submitted_answer"]
                 source = "cache"
                 status = "Loaded from answers_cache.json."
+                log(f"Task {index}/{len(questions_data)} cache hit: {task_id} -> {submitted_answer}")
             else:
                 try:
                     attachment_path, attachment_error = download_attachment(item, api_url, temp_dir)
@@ -153,10 +173,12 @@ def run_agent(profile: gr.OAuthProfile | None, run_all_questions: bool, use_cach
                         "submitted_answer": submitted_answer,
                     }
                     save_cache(cache)
+                    log(f"Task {index}/{len(questions_data)} cached answer: {task_id}")
                 except Exception as exc:
                     submitted_answer = f"AGENT ERROR: {exc}"
                     source = "error"
                     status = str(exc)
+                    log(f"Task {index}/{len(questions_data)} error: {task_id}: {exc}")
 
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append(
@@ -169,7 +191,7 @@ def run_agent(profile: gr.OAuthProfile | None, run_all_questions: bool, use_cach
                     "Status": status,
                 }
             )
-            print(f"[{index}/{len(questions_data)}] {task_id}: {submitted_answer}")
+            log(f"[{index}/{len(questions_data)}] {task_id}: {submitted_answer}")
 
     status = (
         f"Generated {len(answers_payload)} answer(s) for {profile.username}. "
@@ -181,8 +203,12 @@ def run_agent(profile: gr.OAuthProfile | None, run_all_questions: bool, use_cach
 def submit_answers(profile: gr.OAuthProfile | None, answers_payload: list[dict] | None):
     if not profile:
         return "Please log in to Hugging Face first."
+    source_note = "current run"
     if not answers_payload:
-        return "No answers to submit. Run the agent first."
+        answers_payload = cache_to_payload(load_cache())
+        if not answers_payload:
+            return "No answers to submit. Run the agent first."
+        source_note = "answers_cache.json"
 
     space_id = os.getenv("SPACE_ID")
     if space_id:
@@ -203,6 +229,7 @@ def submit_answers(profile: gr.OAuthProfile | None, answers_payload: list[dict]
         return (
             "Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
+            f"Submitted: {len(answers_payload)} answer(s) from {source_note}\n"
             f"Overall Score: {result_data.get('score', 'N/A')}% "
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}\n"
@@ -219,37 +246,44 @@ def submit_answers(profile: gr.OAuthProfile | None, answers_payload: list[dict]
         return f"Submission failed: {exc}"
 
 
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    status, answers_payload, results_df = run_agent(
+        profile=profile,
+        run_all_questions=True,
+        use_cache=True,
+    )
+    if not answers_payload:
+        return status, results_df
+
+    submit_status = submit_answers(profile, answers_payload)
+    return f"{status}\n\n{submit_status}", results_df
+
+
 with gr.Blocks() as demo:
-    gr.Markdown("# Agents Course Unit 4 Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
-        "Generate answers with a Microsoft Agent Framework agent backed by OpenRouter, "
-        "review them, then submit for scoring."
-    )
+        """
+        **Instructions:**
 
-    gr.LoginButton()
+        1. Log in to your Hugging Face account using the button below.
+        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, submit answers, and see the score.
 
-    answers_state = gr.State([])
+        ---
+        **Disclaimers:**
+        This can take quite some time while the agent works through all questions.
+        """
+    )
 
-    with gr.Row():
-        run_all_checkbox = gr.Checkbox(label="Process all questions", value=True)
-        use_cache_checkbox = gr.Checkbox(label="Reuse cached answers", value=True)
+    gr.LoginButton()
 
-    run_button = gr.Button("Run Agent")
-    submit_button = gr.Button("Submit Answers")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Run Status", lines=4, interactive=False)
-    submit_output = gr.Textbox(label="Submission Result", lines=6, interactive=False)
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=8, interactive=False)
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
-        fn=run_agent,
-        inputs=[run_all_checkbox, use_cache_checkbox],
-        outputs=[status_output, answers_state, results_table],
-    )
-    submit_button.click(
-        fn=submit_answers,
-        inputs=[answers_state],
-        outputs=[submit_output],
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table],
     )