Update app.py

app.py

@@ -10,64 +10,77 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # 
+
+
 class BasicAgent:
     """
-    Meta-Llama-3-8B-Instruct
+    Default: Meta-Llama-3-8B-Instruct
     """
-    def __init__(self):
-        # The model we want to use
-        model_id = "meta-llama/Meta-Llama-3-8B-Instruct" #"Qwen/Qwen3-4B-Thinking-2507"
+
+    def __init__(self, model_id: str = "meta-llama/Meta-Llama-3-8B-Instruct"):
+        # Allow custom model_id
+        self.model_id = model_id
         self.api_url = f"https://api-inference.huggingface.co/models/{model_id}"
         
-        # Fetch the token from Space Secrets
+        # Fetch the token from environment
         self.api_token = os.getenv("HF_TOKEN")
         if not self.api_token:
-            raise ValueError("Hugging Face API token not found. Please set the 'HF_TOKEN' secret in your Space settings.")
+            raise ValueError("❌ Hugging Face API token not found. Please set 'HF_TOKEN' as env variable.")
             
         self.headers = {"Authorization": f"Bearer {self.api_token}"}
-        print(f"BasicAgent initialized to use model: {model_id}")
+        print(f"✅ BasicAgent initialized with model: {model_id}")
 
-    def __call__(self, question: str) -> str:
+    def __call__(self, question: str, 
+                 max_new_tokens: int = 512, 
+                 temperature: float = 0.6, 
+                 top_p: float = 0.9) -> str:
         """
         Takes a question, sends it to the LLM via the Inference API, and returns the answer.
         """
-        print(f"Agent received question (first 80 chars): {question[:80]}...")
+        print(f"📝 Agent received question (preview): {question[:80]}...")
 
-        # Llama-3 requires a specific prompt format.
-        # We construct a simple user prompt and let the API handle the full template.
+        # Prompt formatting for Llama-3 style
         payload = {
-            "inputs": f"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n{question}<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n",
+            "inputs": (
+                f"<|begin_of_text|><|start_header_id|>user<|end_header_id|>\n\n"
+                f"{question}\n<|eot_id|><|start_header_id|>assistant<|end_header_id|>\n\n"
+            ),
             "parameters": {
-                "max_new_tokens": 512, # Limit the length of the answer
-                "return_full_text": False, # Only return the generated part
-                "temperature": 0.6, # A bit of creativity
-                "top_p": 0.9, # Nucleus sampling
+                "max_new_tokens": max_new_tokens,
+                "return_full_text": False,
+                "temperature": temperature,
+                "top_p": top_p,
             }
         }
 
         try:
-            print("Querying the Inference API...")
-            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=45)
-            response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+            print("🚀 Querying Hugging Face Inference API...")
+            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=60)
+            response.raise_for_status()  # Raise an error for bad status codes
             
             result = response.json()
 
-            # The response is a list containing a dictionary
+            # Handle error response from HF
+            if isinstance(result, dict) and "error" in result:
+                print(f"⚠️ HF API Error: {result['error']}")
+                return f"Error: {result['error']}"
+
+            # Normal expected case: list of dicts
             if isinstance(result, list) and result:
-                answer = result[0].get("generated_text", "Error: 'generated_text' key not found in API response.")
+                answer = result[0].get("generated_text", "")
             else:
                 answer = f"Error: Unexpected API response format: {result}"
-                print(answer) # Log the unexpected response
-            
-            print(f"Agent returning answer (first 80 chars): {answer.strip()[:80]}...")
+
+            print(f"🤖 Agent returning answer (preview): {answer.strip()[:80]}...")
             return answer.strip()
 
         except requests.exceptions.RequestException as e:
-            print(f"Error during API request: {e}")
+            print(f"❌ API request error: {e}")
             return f"Error: Could not connect to the Inference API. Details: {e}"
         except Exception as e:
-            print(f"An unexpected error occurred in the agent: {e}")
-            return f"Error: An unexpected error occurred while processing the question. Details: {e}"
+            print(f"🔥 Unexpected error in agent: {e}")
+            return f"Error: Unexpected failure while processing. Details: {e}"
+
 
             
 def run_and_submit_all( profile: gr.OAuthProfile | None):