Update app.py

app.py

@@ -10,61 +10,134 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-import os
-import time
+# ----------------------------------------------------------
+import os, json, time
 from functools import lru_cache
+
 from openai import OpenAI, RateLimitError, APIError
+from duckduckgo_search import DDGS      # pip install duckduckgo-search
+
 
-# --- GPT-4o-mini powered agent ------------------------------------------------
-class GPT4oMiniAgent:
+# ---------- simple search helper -------------------------------------------
+def duckduckgo_search(query: str, max_results: int = 5) -> str:
     """
-    Very small wrapper around OpenAI GPT-4o-mini.
-    • Reads the API key from the OPENAI_API_KEY env variable (set as a HF secret)
-    • Uses temperature-0 for deterministic grading
-    • Retries on transient rate-limit / 5xx errors with exponential back-off
-    • Caches identical questions in memory so reruns are near-instant
+    Returns a plain-text bulleted list of the first `max_results`
+    DuckDuckGo results:  Title – URL
+    """
+    print(f"🔍  DuckDuckGo search: {query!r}")
+    bullets = []
+    with DDGS() as ddgs:
+        for r in ddgs.text(query, max_results=max_results):
+            bullets.append(f"- {r['title']} – {r['href']}")
+    if not bullets:
+        return "No results."
+    return "\n".join(bullets[:max_results])
+
+
+# ---------- agent ----------------------------------------------------------
+class GPT4oMiniAgentWithDDG:
     """
-    def __init__(self, max_retries:int=3, backoff:float=2.0):
+    GPT-4o-mini with an optional DuckDuckGo search tool.
+    The model decides – via function-calling – whether it needs live info.
+    """
+    def __init__(self, max_retries: int = 3, backoff: float = 2.0):
         api_key = os.getenv("OPENAI_API_KEY")
         if not api_key:
-            raise EnvironmentError(
-                "OPENAI_API_KEY not found – add it in the Space secrets!"
-            )
+            raise EnvironmentError("OPENAI_API_KEY secret not set!")
+
         self.client = OpenAI(api_key=api_key)
-        self.max_retries = max_retries
-        self.backoff = backoff
+        self.max_retries, self.backoff = max_retries, backoff
+
+        # JSON schema that we register as a tool
+        self.ddg_schema = {
+            "name": "duckduckgo_search",
+            "description": "Search the web for up-to-date information when knowledge cutoff may be too old.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "search string"},
+                    "max_results": {
+                        "type": "integer",
+                        "description": "how many results to return (1-10)",
+                        "default": 5,
+                    },
+                },
+                "required": ["query"],
+            },
+        }
+
         self.system_prompt = (
-            "You are a concise, precise assistant. "
-            "Answer fact questions directly. "
-            "When asked for code, return valid Python in fenced ``` blocks."
+            "You are a concise, accurate assistant.\n"
+            "If you are **certain** you already know the answer, answer directly.\n"
+            "If the question is about very recent events or you are unsure, call "
+            "`duckduckgo_search` to look it up first.\n"
+            "Return final answers in plain language; include citations if you used the web."
         )
-        print("✅ GPT4oMiniAgent initialised.")
 
-    # in-memory cache so if the grader calls the same Q twice we don’t spend tokens
-    @lru_cache(maxsize=256)
-    def __call__(self, question: str) -> str:             # noqa: D401
-        print(f"🔹 Asking gpt-4o-mini: {question[:60]}…")
+        print("✅ GPT4oMiniAgentWithDDG ready.")
+
+    # ----------------------------------------------------------------------
+    # in-memory cache so repeats don’t cost tokens or web calls
+    @lru_cache(maxsize=512)
+    def __call__(self, question: str) -> str:
+        msg_log = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": question},
+        ]
+
+        # 1st request: let model decide if it needs the search tool
+        first = self._chat(msg_log, tools=[self.ddg_schema], tool_choice="auto")
+
+        # If the model called the tool, run it and feed the results back
+        if first.choices[0].message.tool_calls:
+            answer = self._handle_tool_calls(msg_log, first)
+        else:
+            answer = first.choices[0].message.content.strip()
+
+        print(f"🔸 Final answer (trunc.): {answer[:70]}…")
+        return answer
+
+    # ---------- helpers ----------------------------------------------------
+    def _chat(self, messages, **kwargs):
+        """wrapper with retries"""
         for attempt in range(1, self.max_retries + 1):
             try:
-                response = self.client.chat.completions.create(
-                    model="gpt-4o-mini",             # ← official name :contentReference[oaicite:0]{index=0}
-                    messages=[
-                        {"role": "system", "content": self.system_prompt},
-                        {"role": "user", "content": question},
-                    ],
-                    max_tokens=512,
+                return self.client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
                     temperature=0.0,
+                    max_tokens=512,
+                    **kwargs,
                 )
-                answer = response.choices[0].message.content.strip()
-                print(f"🔸 Answer (truncated): {answer[:60]}…")
-                return answer
             except (RateLimitError, APIError) as e:
                 wait = self.backoff * attempt
-                print(f"⚠️  OpenAI error: {e}. Retry {attempt}/{self.max_retries} after {wait}s.")
+                print(f"⚠️  OpenAI error {e}. Retry {attempt}/{self.max_retries} in {wait}s.")
                 time.sleep(wait)
-        # If all retries failed
-        return "I’m sorry, I could not generate an answer due to repeated API errors."
+        raise RuntimeError("OpenAI API failed after retries.")
+
+    def _handle_tool_calls(self, msg_log, first_response):
+        """Execute each requested tool then get the model’s final answer."""
+        for call in first_response.choices[0].message.tool_calls:
+            name = call.function.name
+            args = json.loads(call.function.arguments or "{}")
+            if name == "duckduckgo_search":
+                content = duckduckgo_search(**args)
+            else:
+                content = f"Tool {name} not implemented."
+
+            # Append the tool result so the model can read it
+            msg_log.append(
+                {
+                    "role": "tool",
+                    "tool_call_id": call.id,
+                    "name": name,
+                    "content": content,
+                }
+            )
 
+        # Ask the model again, now that it has the web data
+        final = self._chat(msg_log)
+        return final.choices[0].message.content.strip()
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -87,7 +160,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = GPT4oMiniAgentWithDDG()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None