Update app.py

app.py

@@ -24,19 +24,19 @@ GROQ_MODELS = [
     m.strip()
     for m in os.getenv(
         "GROQ_MODELS",
-        # 8b only — 30K TPM is plenty. 70b's 6K TPM is too tight for tool-calling agents.
+        # 8b only end-to-end. 70b is too tight on free tier and breaks synthesis.
         "llama-3.1-8b-instant",
     ).split(",")
     if m.strip()
 ]
-# Smarter model used ONLY for the final formatting/synthesis pass (one short call -> fits in TPM).
+# Smarter model used for the final synthesis pass. Tried first, falls back to 8b.
 GROQ_FINAL_MODEL = os.getenv("GROQ_FINAL_MODEL", "llama-3.3-70b-versatile")
 GROQ_VISION_MODEL = os.getenv("GROQ_VISION_MODEL", "meta-llama/llama-4-scout-17b-16e-instruct")
 GROQ_WHISPER_MODEL = os.getenv("GROQ_WHISPER_MODEL", "whisper-large-v3-turbo")
 
-MAX_TOOL_ITERATIONS = 6
-TOOL_RESULT_MAX_CHARS = 1400       # tighter -> stays under 6K TPM for 70b
-HISTORY_TRIM_AFTER = 5             # trim aggressively
+MAX_TOOL_ITERATIONS = 7
+TOOL_RESULT_MAX_CHARS = 1500
+HISTORY_TRIM_AFTER = 6
 ANSWER_CACHE_PATH = os.getenv("ANSWER_CACHE_PATH", "/tmp/answers_cache.json")
 RESULTS_CSV_PATH = "/tmp/gaia_results.csv"
 INTER_QUESTION_SLEEP = float(os.getenv("INTER_QUESTION_SLEEP", "3"))
@@ -61,28 +61,30 @@ def tool_web_search(query: str, max_results: int = 5) -> str:
                 search_depth="basic",
                 include_answer=True,
             )
-            lines = []
+            lines = ["[provider: tavily]"]
             if res.get("answer"):
                 lines.append(f"Answer: {res['answer']}")
             for r in res.get("results", [])[:max_results]:
                 lines.append(
                     f"- {r.get('title', '')}\n  {r.get('url', '')}\n  {r.get('content', '')[:300]}"
                 )
-            if lines:
+            if len(lines) > 1:
                 return "\n".join(lines)
         except Exception as e:
             print(f"tavily search failed, falling back to DDG: {e}")
+    else:
+        print("[search] TAVILY_API_KEY not set; using DDG.")
 
     try:
         from duckduckgo_search import DDGS
-        results = []
+        results = ["[provider: duckduckgo]"]
         with DDGS() as ddgs:
             for r in ddgs.text(query, max_results=max_results):
                 results.append(
                     f"- {r.get('title', '')}\n  {r.get('href', '')}\n  {r.get('body', '')[:300]}"
                 )
-        if not results:
-            return "No results."
+        if len(results) == 1:
+            return "[provider: duckduckgo] No results."
         return "\n".join(results)
     except Exception as e:
         return f"web_search error: {e}"
@@ -701,11 +703,11 @@ class GroqAgent:
         return self._synthesize(question, collected_facts)
 
     def _synthesize(self, question: str, facts: list[str]) -> str:
-        """Final answer pass on a short context. Uses smarter model if available."""
-        # Keep total facts under ~3500 chars to be safe with TPM on 70b.
-        joined = "\n\n".join(facts[-6:])  # last 6 tool outputs
-        if len(joined) > 3500:
-            joined = joined[-3500:]
+        """Final answer pass on a short context. Tries smarter model first."""
+        # Keep total facts well under any TPM cap.
+        joined = "\n\n".join(facts[-6:])
+        if len(joined) > 2500:
+            joined = joined[-2500:]
 
         synth_messages = [
             {
@@ -715,7 +717,10 @@ class GroqAgent:
                     "research notes below, then output ONLY the final answer string. "
                     "No preamble, no labels, no explanation, no quotes, no trailing period. "
                     "Match the question's required format exactly (number-only / IOC code / "
-                    "first name only / two-decimal currency / comma-space list / etc.)."
+                    "first name only / surname only / two-decimal currency / comma-space list). "
+                    "If the notes are insufficient, give your single best guess based on "
+                    "general knowledge in the same strict format. Never refuse, never apologize, "
+                    "never reply with an empty string."
                 ),
             },
             {
@@ -728,7 +733,11 @@ class GroqAgent:
             },
         ]
         # Try the smarter final model first; fall back to the regular pool.
+        attempts = []
         for model_choice in (GROQ_FINAL_MODEL, *self.models):
+            if model_choice in attempts:
+                continue
+            attempts.append(model_choice)
             try:
                 resp = self._chat(synth_messages, use_tools=False, max_tokens=120, model=model_choice)
                 ans = (resp.choices[0].message.content or "").strip()
@@ -738,7 +747,23 @@ class GroqAgent:
             except Exception as e:
                 print(f"synth with {model_choice} failed: {e}")
                 continue
-        return ""
+        # Last-resort: zero-shot guess with no notes, smallest possible prompt.
+        try:
+            resp = self._chat(
+                [
+                    {"role": "system", "content": "Answer in 1-5 words. No explanation."},
+                    {"role": "user", "content": question[:500]},
+                ],
+                use_tools=False,
+                max_tokens=40,
+                model=self.models[0],
+            )
+            return self._postprocess_answer(
+                (resp.choices[0].message.content or "").strip(), question
+            )
+        except Exception as e:
+            print(f"last-resort guess failed: {e}")
+            return "unknown"
 
     def _finalize(self, raw: str, question: str, facts: list[str] | None = None) -> str:
         """Post-process and, if the answer still looks like a sentence, ask the model to reformat."""