Update app.py

app.py

@@ -18,6 +18,7 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 GROQ_MODELS = [
     m.strip()
     for m in os.getenv(
+        "GROQ_MODELS",
         "llama-3.3-70b-versatile,llama-3.1-8b-instant",
     ).split(",")
     if m.strip()
@@ -47,7 +48,7 @@ def tool_web_search(query: str, max_results: int = 5) -> str:
         return f"web_search error: {e}"
 
 
-def tool_fetch_url(url: str, max_chars: int = 6000) -> str:
+def tool_fetch_url(url: str, max_chars: int = 3000) -> str:
     """Fetch a URL and return readable text (HTML stripped)."""
     try:
         from bs4 import BeautifulSoup
@@ -75,7 +76,7 @@ def tool_fetch_url(url: str, max_chars: int = 6000) -> str:
         return f"fetch_url error: {e}"
 
 
-def tool_wikipedia(query: str, sentences: int = 6) -> str:
+def tool_wikipedia(query: str, sentences: int = 4) -> str:
     """Look up a topic on Wikipedia and return a summary."""
     try:
         import wikipedia
@@ -133,7 +134,7 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
                 text = resp.content.decode("utf-8", errors="replace")
             except Exception:
                 text = resp.text
-            return info + "\n--- preview ---\n" + text[:6000]
+            return info + "\n--- preview ---\n" + text[:3000]
 
         if suffix in {".xlsx", ".xls"}:
             try:
@@ -146,8 +147,8 @@ def tool_get_task_file(task_id: str, api_url: str = DEFAULT_API_URL) -> str:
             try:
                 from pypdf import PdfReader
                 reader = PdfReader(tmp.name)
-                pages = [p.extract_text() or "" for p in reader.pages[:10]]
-                return info + "\n--- pdf text (first 10 pages) ---\n" + "\n".join(pages)[:6000]
+                pages = [p.extract_text() or "" for p in reader.pages[:8]]
+                return info + "\n--- pdf text (first 8 pages) ---\n" + "\n".join(pages)[:3000]
             except Exception as e:
                 return info + f"\n(pdf parse error: {e})"
 
@@ -190,7 +191,7 @@ TOOLS_SPEC = [
                 "type": "object",
                 "properties": {
                     "url": {"type": "string"},
-                    "max_chars": {"type": "integer", "default": 6000},
+                    "max_chars": {"type": "integer", "default": 3000},
                 },
                 "required": ["url"],
             },
@@ -205,7 +206,7 @@ TOOLS_SPEC = [
                 "type": "object",
                 "properties": {
                     "query": {"type": "string"},
-                    "sentences": {"type": "integer", "default": 6},
+                    "sentences": {"type": "integer", "default": 4},
                 },
                 "required": ["query"],
             },
@@ -239,8 +240,8 @@ TOOLS_SPEC = [
 
 TOOL_FUNCTIONS = {
     "web_search": lambda args: tool_web_search(args["query"], int(args.get("max_results", 5))),
-    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 6000))),
-    "wikipedia": lambda args: tool_wikipedia(args["query"], int(args.get("sentences", 6))),
+    "fetch_url": lambda args: tool_fetch_url(args["url"], int(args.get("max_chars", 3000))),
+    "wikipedia": lambda args: tool_wikipedia(args["query"], int(args.get("sentences", 4))),
     "python": lambda args: tool_python(args["code"]),
     "get_task_file": lambda args: tool_get_task_file(args["task_id"]),
 }
@@ -283,9 +284,61 @@ class GroqAgent:
                 "GROQ_API_KEY is not set. Add it as a Secret in your HF Space settings."
             )
         self.client = Groq(api_key=api_key)
-        self.model = GROQ_MODEL
-        print(f"GroqAgent initialized with model={self.model}")
+        self.models = list(GROQ_MODELS)
+        # Track models that hit a daily-token cap; skip them for the rest of the run.
+        self.exhausted_models: set[str] = set()
+        print(f"GroqAgent initialized with models={self.models}")
+
+    # ---- Groq call with model fallback + 429 handling -------------------
+    def _chat(self, messages, use_tools: bool = True, max_tokens: int = 1024):
+        last_error: Exception | None = None
+        for model in self.models:
+            if model in self.exhausted_models:
+                continue
+            for attempt in range(3):
+                try:
+                    kwargs = dict(
+                        model=model,
+                        messages=messages,
+                        temperature=0.0,
+                        max_tokens=max_tokens,
+                    )
+                    if use_tools:
+                        kwargs["tools"] = TOOLS_SPEC
+                        kwargs["tool_choice"] = "auto"
+                    return self.client.chat.completions.create(**kwargs)
+                except Exception as e:
+                    msg = str(e)
+                    last_error = e
+                    is_429 = "429" in msg or "rate_limit" in msg.lower()
+                    is_tpd = "per day" in msg.lower() or "tpd" in msg.lower()
+                    if is_429 and is_tpd:
+                        # Daily quota gone — switch model permanently for this run.
+                        print(f"[{model}] daily token limit exhausted; switching model.")
+                        self.exhausted_models.add(model)
+                        break
+                    if is_429:
+                        wait = self._parse_retry_seconds(msg)
+                        wait = min(max(wait, 2), 30)
+                        print(f"[{model}] 429 rate limit; sleeping {wait}s (attempt {attempt + 1}/3)")
+                        time.sleep(wait)
+                        continue
+                    # Non-429 error: don't retry on the same model.
+                    print(f"[{model}] API error: {e}")
+                    break
+        raise RuntimeError(f"All Groq models failed. Last error: {last_error}")
 
+    @staticmethod
+    def _parse_retry_seconds(error_msg: str) -> float:
+        # Examples in Groq error: "Please try again in 7m18.912s." or "in 12.3s"
+        m = re.search(r"in\s+(?:(\d+)m)?([\d.]+)s", error_msg)
+        if not m:
+            return 5.0
+        minutes = int(m.group(1)) if m.group(1) else 0
+        seconds = float(m.group(2)) if m.group(2) else 0.0
+        return minutes * 60 + seconds
+
+    # ---- Main entrypoint ------------------------------------------------
     def __call__(self, question: str, task_id: str | None = None) -> str:
         user_content = question
         if task_id:
@@ -298,16 +351,8 @@ class GroqAgent:
 
         for step in range(MAX_TOOL_ITERATIONS):
             try:
-                resp = self.client.chat.completions.create(
-                    model=self.model,
-                    messages=messages,
-                    tools=TOOLS_SPEC,
-                    tool_choice="auto",
-                    temperature=0.0,
-                    max_tokens=1024,
-                )
+                resp = self._chat(messages, use_tools=True, max_tokens=1024)
             except Exception as e:
-                print(f"Groq API error: {e}")
                 return f"AGENT ERROR: {e}"
 
             msg = resp.choices[0].message
@@ -317,7 +362,6 @@ class GroqAgent:
                 answer = (msg.content or "").strip()
                 return self._postprocess_answer(answer)
 
-            # Append assistant message with the tool calls
             messages.append(
                 {
                     "role": "assistant",
@@ -354,8 +398,8 @@ class GroqAgent:
 
                 if not isinstance(result, str):
                     result = str(result)
-                if len(result) > 8000:
-                    result = result[:8000] + "\n...[truncated]"
+                if len(result) > TOOL_RESULT_MAX_CHARS:
+                    result = result[:TOOL_RESULT_MAX_CHARS] + "\n...[truncated]"
 
                 messages.append(
                     {
@@ -366,7 +410,7 @@ class GroqAgent:
                     }
                 )
 
-        # Out of iterations: ask for a final, no-tool answer
+        # Out of tool iterations: ask for a final, no-tool answer.
         messages.append(
             {
                 "role": "user",
@@ -374,12 +418,7 @@ class GroqAgent:
             }
         )
         try:
-            resp = self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                temperature=0.0,
-                max_tokens=256,
-            )
+            resp = self._chat(messages, use_tools=False, max_tokens=256)
             return self._postprocess_answer((resp.choices[0].message.content or "").strip())
         except Exception as e:
             return f"AGENT ERROR: {e}"
@@ -388,15 +427,32 @@ class GroqAgent:
     def _postprocess_answer(text: str) -> str:
         if not text:
             return ""
-        # Strip common prefixes the model may sneak in despite instructions.
         text = text.strip()
         text = re.sub(r"^(final answer|answer)\s*:\s*", "", text, flags=re.IGNORECASE)
-        # Remove surrounding quotes/backticks
         if len(text) >= 2 and text[0] == text[-1] and text[0] in {'"', "'", "`"}:
             text = text[1:-1].strip()
         return text
 
 
+# ---------------------------------------------------------------------------
+# Answer cache so a failed run doesn't waste tokens
+# ---------------------------------------------------------------------------
+def _load_cache() -> dict:
+    try:
+        with open(ANSWER_CACHE_PATH, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def _save_cache(cache: dict) -> None:
+    try:
+        with open(ANSWER_CACHE_PATH, "w", encoding="utf-8") as f:
+            json.dump(cache, f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        print(f"cache save error: {e}")
+
+
 # ---------------------------------------------------------------------------
 # Gradio submission flow
 # ---------------------------------------------------------------------------
@@ -437,6 +493,9 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     results_log = []
     answers_payload = []
+    cache = _load_cache()
+    if cache:
+        print(f"Loaded {len(cache)} cached answers from {ANSWER_CACHE_PATH}")
     print(f"Running agent on {len(questions_data)} questions...")
     for idx, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
@@ -445,11 +504,18 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         print(f"\n=== [{idx}/{len(questions_data)}] task_id={task_id} ===")
-        try:
-            submitted_answer = agent(question_text, task_id=task_id)
-        except Exception as e:
-            print(f"Error running agent on task {task_id}: {e}")
-            submitted_answer = f"AGENT ERROR: {e}"
+        cached = cache.get(task_id)
+        if cached and not str(cached).startswith("AGENT ERROR"):
+            submitted_answer = cached
+            print(f"(cache hit) {submitted_answer[:80]}")
+        else:
+            try:
+                submitted_answer = agent(question_text, task_id=task_id)
+            except Exception as e:
+                print(f"Error running agent on task {task_id}: {e}")
+                submitted_answer = f"AGENT ERROR: {e}"
+            cache[task_id] = submitted_answer
+            _save_cache(cache)
         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}
@@ -465,31 +531,50 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     }
     print(f"Submitting {len(answers_payload)} answers for user '{username}'...")
 
-    try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
-        response.raise_for_status()
-        result_data = response.json()
-        final_status = (
-            f"Submission Successful!\n"
-            f"User: {result_data.get('username')}\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.')}"
-        )
-        return final_status, pd.DataFrame(results_log)
-    except requests.exceptions.HTTPError as e:
-        error_detail = f"Server responded with status {e.response.status_code}."
+    # Retry submission a few times — the leaderboard's HF dataset write is flaky.
+    last_error = None
+    for attempt in range(3):
         try:
-            error_detail += f" Detail: {e.response.json().get('detail', e.response.text)}"
-        except requests.exceptions.JSONDecodeError:
-            error_detail += f" Response: {e.response.text[:500]}"
-        return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
-    except requests.exceptions.Timeout:
-        return "Submission Failed: The request timed out.", pd.DataFrame(results_log)
-    except requests.exceptions.RequestException as e:
-        return f"Submission Failed: Network error - {e}", pd.DataFrame(results_log)
-    except Exception as e:
-        return f"An unexpected error occurred during submission: {e}", pd.DataFrame(results_log)
+            response = requests.post(submit_url, json=submission_data, timeout=120)
+            response.raise_for_status()
+            result_data = response.json()
+            final_status = (
+                f"Submission Successful!\n"
+                f"User: {result_data.get('username')}\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.')}"
+            )
+            return final_status, pd.DataFrame(results_log)
+        except requests.exceptions.HTTPError as e:
+            status = e.response.status_code if e.response is not None else "?"
+            last_error = e
+            print(f"Submission attempt {attempt + 1} failed: HTTP {status}")
+            if status and 500 <= int(status) < 600:
+                time.sleep(5 * (attempt + 1))
+                continue
+            error_detail = f"Server responded with status {status}."
+            try:
+                error_detail += f" Detail: {e.response.json().get('detail', e.response.text)}"
+            except Exception:
+                error_detail += f" Response: {e.response.text[:500] if e.response is not None else ''}"
+            return f"Submission Failed: {error_detail}", pd.DataFrame(results_log)
+        except requests.exceptions.Timeout as e:
+            last_error = e
+            print(f"Submission attempt {attempt + 1} timed out.")
+            time.sleep(5 * (attempt + 1))
+            continue
+        except requests.exceptions.RequestException as e:
+            last_error = e
+            print(f"Submission attempt {attempt + 1} network error: {e}")
+            time.sleep(5 * (attempt + 1))
+            continue
+
+    return (
+        f"Submission Failed after retries: {last_error}. Answers are cached at "
+        f"{ANSWER_CACHE_PATH} — re-run to retry without re-querying the model.",
+        pd.DataFrame(results_log),
+    )
 
 
 # --- Gradio UI ---
@@ -499,10 +584,11 @@ with gr.Blocks() as demo:
         """
         **Setup**
         1. Add a Space secret named `GROQ_API_KEY` with your Groq API key.
-        2. Optional: set `GROQ_MODEL` (default `llama-3.3-70b-versatile`).
+        2. Optional: set `GROQ_MODELS` (comma-separated, default `llama-3.3-70b-versatile,llama-3.1-8b-instant`).
         3. Log in to Hugging Face below and click **Run Evaluation & Submit All Answers**.
 
         Tools available to the agent: `web_search`, `fetch_url`, `wikipedia`, `python`, `get_task_file`.
+        Answers are cached locally, so a failed submission can be retried without re-running the agent.
         """
     )