Update app.py

app.py

@@ -3,107 +3,141 @@ import gradio as gr
 import requests
 import pandas as pd
 import time
-import random
 import re
 import math
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Provider-agnostic lightweight LLM client (no HF Inference API) ---
+# ------- Lightweight utilities -------
 
-class LLMClient:
+def maybe_compute_locally(question: str) -> Optional[str]:
     """
-    Pluggable LLM client with robust 429/5xx backoff.
-    Supported providers via env LLM_PROVIDER:
-      - openai       (OPENAI_API_KEY, model via OPENAI_MODEL, base via OPENAI_BASE_URL)
-      - together     (TOGETHER_API_KEY, model via TOGETHER_MODEL, base via TOGETHER_BASE_URL)
-      - openrouter   (OPENROUTER_API_KEY, model via OPENROUTER_MODEL, base fixed)
-    Defaults pick small reasoning-capable models.
+    Fast, safe arithmetic for simple GAIA-style math.
     """
+    text = question.strip().lower()
+    match = re.search(r"(?:calculate|compute|what is|evaluate)\s*[:\-]?\s*(.+)", text)
+    expr = match.group(1).strip() if match else text
+    expr = expr.replace("×", "*").replace("÷", "/").replace("^", "**")
+    expr = re.sub(r"(\d+)\s+percent", r"(\1/100)", expr)
+    # Only allow digits, ops, dots, spaces, parentheses
+    clean = expr.replace("**", "")
+    if not re.fullmatch(r"[0-9\.\s\+\-\*\/\(\)]+", clean):
+        return None
+    try:
+        result = eval(expr, {"__builtins__": {}}, {"sqrt": math.sqrt, "pow": pow})
+    except Exception:
+        return None
+    if isinstance(result, float):
+        result = 0.0 if abs(result) < 1e-12 else round(result, 6)
+    return str(result)
 
+# ------- Wikipedia retrieval (fast, no API key) -------
+
+WIKI_API = "https://en.wikipedia.org/w/api.php"
+
+def wiki_search(query: str, limit: int = 3, timeout: int = 10) -> List[Dict[str, Any]]:
+    params = {
+        "action": "query",
+        "list": "search",
+        "srsearch": query,
+        "srlimit": limit,
+        "utf8": "1",
+        "format": "json",
+    }
+    r = requests.get(WIKI_API, params=params, timeout=timeout)
+    r.raise_for_status()
+    data = r.json()
+    return data.get("query", {}).get("search", [])
+
+def wiki_extracts_by_pageids(pageids: List[int], timeout: int = 10) -> Dict[int, str]:
+    if not pageids:
+        return {}
+    params = {
+        "action": "query",
+        "prop": "extracts",
+        "explaintext": "1",
+        "exintro": "1",
+        "pageids": "|".join(str(pid) for pid in pageids),
+        "format": "json",
+        "utf8": "1",
+    }
+    r = requests.get(WIKI_API, params=params, timeout=timeout)
+    r.raise_for_status()
+    data = r.json()
+    pages = data.get("query", {}).get("pages", {})
+    out: Dict[int, str] = {}
+    for pid, meta in pages.items():
+        try:
+            out[int(pid)] = (meta.get("extract") or "").strip()
+        except Exception:
+            continue
+    return out
+
+def retrieve_wikipedia_snippets(query: str, k: int = 3) -> List[Tuple[str, str]]:
+    """
+    Returns list of (title, snippet_text).
+    """
+    try:
+        hits = wiki_search(query, limit=k)
+        pageids = [h.get("pageid") for h in hits if isinstance(h.get("pageid"), int)]
+        extracts = wiki_extracts_by_pageids(pageids)
+        results: List[Tuple[str, str]] = []
+        for h in hits:
+            pid = h.get("pageid")
+            title = h.get("title", "")
+            extract = extracts.get(pid, "") if isinstance(pid, int) else ""
+            snippet = extract if extract else re.sub("<.*?>", "", h.get("snippet", "")).strip()
+            if title and snippet:
+                # take first 2 sentences to be concise
+                first_two = re.split(r"(?<=[.!?])\s+", snippet)[:2]
+                results.append((title, " ".join(first_two)))
+        return results
+    except Exception:
+        return []
+
+# ------- Minimal LLM client (single provider, optional) -------
+
+class LLMClient:
+    """
+    Single-shot caller with tiny retry. Defaults to OpenRouter (cheapest path).
+    Set one of:
+      - OPENAI_API_KEY + OPENAI_MODEL + OPENAI_BASE_URL
+      - or OPENROUTER_API_KEY + OPENROUTER_MODEL (default used if key present)
+    Priority: OPENAI if key present, else OPENROUTER if key present, else disabled.
+    """
     def __init__(self):
-        self.provider = (os.getenv("LLM_PROVIDER") or "openai").strip().lower()
+        self.provider: Optional[str] = None
+        self.headers: Dict[str, str] = {}
+        self.base_url: Optional[str] = None
+        self.model: Optional[str] = None
 
-        if self.provider == "openai":
-            self.api_key = os.getenv("OPENAI_API_KEY")
-            if not self.api_key:
-                raise ValueError("OPENAI_API_KEY is required when LLM_PROVIDER=openai.")
-            # Reasoning-lite default
-            self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        openai_key = os.getenv("OPENAI_API_KEY")
+        openrouter_key = os.getenv("OPENROUTER_API_KEY")
+
+        if openai_key:
+            self.provider = "openai"
             self.base_url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1")
-            self.headers = {
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-            }
-
-        elif self.provider == "together":
-            self.api_key = os.getenv("TOGETHER_API_KEY")
-            if not self.api_key:
-                raise ValueError("TOGETHER_API_KEY is required when LLM_PROVIDER=together.")
-            self.model = os.getenv("TOGETHER_MODEL", "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo")
-            self.base_url = os.getenv("TOGETHER_BASE_URL", "https://api.together.xyz/v1")
-            self.headers = {
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-            }
-
-        elif self.provider == "openrouter":
-            self.api_key = os.getenv("OPENROUTER_API_KEY")
-            if not self.api_key:
-                raise ValueError("OPENROUTER_API_KEY is required when LLM_PROVIDER=openrouter.")
-            # Strong, cost-effective default; change as desired
-            self.model = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.1-8b-instruct:free")
+            self.model = os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+            self.headers = {"Authorization": f"Bearer {openai_key}", "Content-Type": "application/json"}
+        elif openrouter_key:
+            self.provider = "openrouter"
             self.base_url = "https://openrouter.ai/api/v1"
-            self.headers = {
-                "Authorization": f"Bearer {self.api_key}",
-                "Content-Type": "application/json",
-            }
-
+            self.model = os.getenv("OPENROUTER_MODEL", "meta-llama/llama-3.1-8b-instruct:free")
+            self.headers = {"Authorization": f"Bearer {openrouter_key}", "Content-Type": "application/json"}
         else:
-            raise ValueError("LLM_PROVIDER must be one of: openai, together, openrouter")
+            self.provider = None
 
-        # Backoff settings
-        self.max_retries = int(os.getenv("MAX_RETRIES", "8"))
-        self.base_backoff = float(os.getenv("BASE_BACKOFF", "1.0"))  # seconds
-        self.max_backoff = float(os.getenv("MAX_BACKOFF", "30.0"))   # cap
+    def available(self) -> bool:
+        return self.provider is not None
 
-    def _post_with_backoff(self, url: str, headers: Dict[str, Any], payload: Dict[str, Any], timeout: int = 120) -> requests.Response:
-        delay = self.base_backoff
-        last_exc = None
-        for attempt in range(1, self.max_retries + 1):
-            try:
-                resp = requests.post(url, headers=headers, json=payload, timeout=timeout)
-                if resp.status_code in (429, 500, 502, 503, 504):
-                    retry_after = resp.headers.get("Retry-After")
-                    if retry_after:
-                        try:
-                            delay = max(delay, float(retry_after))
-                        except Exception:
-                            pass
-                    jitter = random.uniform(0, delay * 0.25)
-                    wait_s = min(delay + jitter, self.max_backoff)
-                    print(f"⏳ {self.provider} {resp.status_code}. Attempt {attempt}/{self.max_retries}. Waiting {wait_s:.2f}s...")
-                    time.sleep(wait_s)
-                    delay = min(delay * 1.8, self.max_backoff)
-                    continue
-                return resp
-            except requests.exceptions.RequestException as e:
-                last_exc = e
-                jitter = random.uniform(0, delay * 0.25)
-                wait_s = min(delay + jitter, self.max_backoff)
-                print(f"⚠️ Network error on attempt {attempt}/{self.max_retries}: {e}. Waiting {wait_s:.2f}s...")
-                time.sleep(wait_s)
-                delay = min(delay * 1.8, self.max_backoff)
-        if last_exc:
-            raise last_exc
-        return requests.post(url, headers=headers, json=payload, timeout=timeout)
-
-    def chat(self, system_prompt: str, user_prompt: str, max_tokens: int = 512, temperature: float = 0.6, top_p: float = 0.9) -> str:
+    def chat(self, system_prompt: str, user_prompt: str, max_tokens: int = 192, temperature: float = 0.3) -> str:
+        if not self.available():
+            return "LLM unavailable"
         url = f"{self.base_url}/chat/completions"
-        payload: Dict[str, Any] = {
+        payload = {
             "model": self.model,
             "messages": [
                 {"role": "system", "content": system_prompt},
@@ -111,153 +145,82 @@ class LLMClient:
             ],
             "max_tokens": max_tokens,
             "temperature": temperature,
-            "top_p": top_p,
+            "top_p": 0.9,
         }
-
-        try:
-            resp = self._post_with_backoff(url, headers=self.headers, payload=payload, timeout=120)
-            if resp.status_code == 404:
-                return (
-                    f"Error: 404 from {self.provider} API. Check model name and base URL.\n"
-                    f"Requested URL: {url}\nModel: {self.model}"
-                )
-            resp.raise_for_status()
-            data = resp.json()
-            text = data.get("choices", [{}])[0].get("message", {}).get("content", "")
-            return (text or "").strip()
-        except requests.exceptions.RequestException as e:
-            return f"Error: Could not connect to {self.provider} API. Details: {e}"
-        except Exception as e:
-            return f"Error: Unexpected failure while processing. Details: {e}"
-
-# --- Simple tool-use: safe-ish arithmetic and unit conversions ---
-
-def maybe_compute_locally(question: str) -> Optional[str]:
-    """
-    Lightweight math helper for common GAIA-style arithmetic/unit questions.
-    Avoids eval of arbitrary text; only allows digits, ops, dots, spaces, and parentheses.
-    Returns a computed answer string or None to defer to LLM.
-    """
-    # Quick patterns: pure arithmetic, percents, simple ratios, sqrt, powers
-    text = question.strip().lower()
-
-    # Extract expression inside "calculate"/"compute"/"what is"
-    match = re.search(r"(?:calculate|compute|what is|evaluate)\s*[:\-]?\s*(.+)", text)
-    expr = match.group(1).strip() if match else text
-
-    # Replace common words to operators
-    expr = expr.replace("×", "*").replace("÷", "/").replace("^", "**")
-    expr = re.sub(r"(\d+)\s+percent", r"(\1/100)", expr)
-
-    # Allow only safe characters
-    if not re.fullmatch(r"[0-9\.\s\+\-\*\/\(\)\%]+", re.sub(r"\*\*", "**", expr)):
-        return None
-
-    # Disallow modulo for now (often not needed)
-    if "%" in expr:
-        return None
-
-    try:
-        # Use Python arithmetic safely
-        result = eval(expr, {"__builtins__": {}}, {"sqrt": math.sqrt, "pow": pow})
-    except Exception:
-        return None
-
-    if isinstance(result, float):
-        # Round to a reasonable precision
-        result = round(result, 6)
-        # normalize -0.0
-        if result == 0:
-            result = 0.0
-    return str(result)
-
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+        for attempt in range(3):
+            try:
+                resp = requests.post(url, headers=self.headers, json=payload, timeout=60)
+                if resp.status_code in (429, 500, 502, 503, 504):
+                    time.sleep(1.5 * (attempt + 1))
+                    continue
+                resp.raise_for_status()
+                data = resp.json()
+                text = data.get("choices", [{}])[0].get("message", {}).get("content", "")
+                return (text or "").strip()
+            except Exception as e:
+                if attempt == 2:
+                    return f"LLM error: {e}"
+                time.sleep(1.0)
+        return "LLM error"
+
+# --- Basic Agent Definition (lean) ---
 
 class BasicAgent:
     def __init__(self):
-        # Config
-        self.rate_limit_s = float(os.getenv("RATE_LIMIT_SECONDS", "1.0"))
-        self.max_new_tokens = int(os.getenv("MAX_NEW_TOKENS", "256"))
-        self.samples = int(os.getenv("NUM_SAMPLES", "3"))  # self-consistency votes
-        self.temperature = float(os.getenv("TEMPERATURE", "0.6"))
-        self.top_p = float(os.getenv("TOP_P", "0.9"))
-
-        # System prompt optimized for concise, correct answers
-        self.system_prompt = (
-            "You are a precise reasoning assistant. Answer with the final result only, "
-            "without extra explanations, unless the question explicitly asks for steps or justification. "
-            "Prefer exact values, otherwise numeric to a sensible precision. Be factual and avoid speculation."
-        )
-
-        # LLM client (non-HF endpoints)
         self.client = LLMClient()
-        print(f"BasicAgent initialized with provider={self.client.provider}, model={self.client.model}, samples={self.samples}")
+        self.max_new_tokens = int(os.getenv("MAX_NEW_TOKENS", "192"))
+        print(f"BasicAgent initialized. LLM={'on' if self.client.available() else 'off'}")
 
     def _finalize(self, text: str) -> str:
-        # Trim quotes, code fences, and whitespace
-        t = text.strip()
-        t = re.sub(r"^```.*?\n", "", t, flags=re.DOTALL)  # remove starting fence if any
-        t = t.strip("` \n")
-        # Collapse multiple spaces
+        t = text.strip().strip("`")
         t = re.sub(r"\s+", " ", t)
-        return t.strip()
+        return t
 
-    def _sample_answer(self, question: str) -> str:
-        # Try local compute first for arithmetic-like prompts
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+
+        # 1) Fast local math if applicable
         local = maybe_compute_locally(question)
         if local is not None:
+            print("Answered via local compute.")
             return local
 
-        # Otherwise query the LLM
-        reply = self.client.chat(
-            system_prompt=self.system_prompt,
-            user_prompt=question,
-            max_tokens=self.max_new_tokens,
-            temperature=self.temperature,
-            top_p=self.top_p,
+        # 2) Wikipedia retrieve
+        snippets = retrieve_wikipedia_snippets(question, k=3)
+
+        # 3) If no LLM available, respond with best snippet sentence
+        if not self.client.available():
+            if snippets:
+                title, snip = snippets[0]
+                ans = self._finalize(snip)
+                print(f"Answered via Wikipedia snippet ({title}).")
+                return ans
+            print("No LLM and no snippets; returning fallback.")
+            return "I cannot determine the answer."
+
+        # 4) Compose minimal prompt with top snippets to keep tokens low
+        context_lines = []
+        for title, snip in snippets[:3]:
+            context_lines.append(f"- {title}: {snip}")
+        context = "\n".join(context_lines) if context_lines else "(no external context found)"
+
+        system_prompt = (
+            "You answer factually and concisely. Use the provided context if helpful. "
+            "Return only the final answer, no extra text."
         )
-        return self._finalize(reply)
+        user_prompt = f"Question: {question}\nContext:\n{context}\nAnswer:"
 
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        reply = self.client.chat(system_prompt, user_prompt, max_tokens=self.max_new_tokens, temperature=0.3)
+        answer = self._finalize(reply)
 
-        # Self-consistency: multiple samples and vote
-        candidates: List[str] = []
-        for i in range(max(1, self.samples)):
-            ans = self._sample_answer(question)
-            candidates.append(ans)
-            print(f"  sample {i+1}/{self.samples}: {ans[:100]}")
-            if i < self.samples - 1:
-                time.sleep(self.rate_limit_s)
-
-        # Majority vote by normalized string; numeric-aware normalization
-        normalized_counts: Dict[str, int] = {}
-        mapping: Dict[str, str] = {}
-
-        def normalize(s: str) -> str:
-            s_clean = s.strip().lower()
-            # Try extract number
-            num = re.findall(r"-?\d+(?:\.\d+)?", s_clean)
-            if len(num) == 1 and s_clean.replace(num[0], "").strip() in ["", "units", "unit"]:
-                try:
-                    val = float(num[0])
-                    return f"{round(val, 6)}"
-                except Exception:
-                    pass
-            return s_clean
-
-        for c in candidates:
-            key = normalize(c)
-            normalized_counts[key] = normalized_counts.get(key, 0) + 1
-            # Keep first original for formatting
-            if key not in mapping:
-                mapping[key] = c
-
-        best_key = max(normalized_counts, key=normalized_counts.get)
-        final = mapping[best_key]
-        print(f"Agent returning answer: {final}")
-        return final
+        # 5) If the model failed, fall back to best snippet
+        if not answer or answer.lower().startswith("llm error"):
+            if snippets:
+                answer = self._finalize(snippets[0][1])
+            else:
+                answer = "I cannot determine the answer."
+        print(f"Agent returning answer: {answer[:80]}")
+        return answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -278,13 +241,12 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
+    # 1. Instantiate Agent
     try:
         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)
 
@@ -313,7 +275,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    for idx, item in enumerate(questions_data, start=1):
+    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:
@@ -401,7 +363,6 @@ with gr.Blocks() as demo:
     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(
@@ -411,7 +372,6 @@ with gr.Blocks() as demo:
 
 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") # Get SPACE_ID at startup