Update app.py

app.py

@@ -3,9 +3,6 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import time
-from typing import Optional, Dict, Any
-from requests.adapters import HTTPAdapter, Retry
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -20,62 +17,16 @@ class BasicAgent:
     Default: Meta-Llama-3-8B-Instruct
     """
 
-    def __init__(self, model_id: str = "meta-llama/Meta-Llama-3-8B-Instruct"):
-        # Allow env override for model_id
+    # In __init__ of BasicAgent
+    def __init__(self, model_id: str = "HuggingFaceH4/zephyr-7b-beta"):
         model_id_env = os.getenv("HF_MODEL_ID")
         self.model_id = model_id_env.strip() if model_id_env else model_id
-
-        # Correct HF Inference API endpoint
         self.api_url = f"https://api-inference.huggingface.co/models/{self.model_id}"
-        
-        # 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 'HF_TOKEN' as env variable.")
-            
         self.headers = {"Authorization": f"Bearer {self.api_token}"}
-
-        # Requests session with retries/backoff for 429/5xx and model loading
-        self.session = requests.Session()
-        retries = Retry(
-            total=6,
-            backoff_factor=1.5,
-            status_forcelist=[429, 500, 502, 503, 504],
-            allowed_methods=frozenset(["POST", "GET"]),
-            raise_on_status=False,
-        )
-        self.session.mount("https://", HTTPAdapter(max_retries=retries))
-        self.session.mount("http://", HTTPAdapter(max_retries=retries))
-
-        print(f"✅ BasicAgent initialized with model: {self.model_id}")
-
-    def _post_with_retries(self, url: str, json: Dict[str, Any], timeout: int = 60) -> requests.Response:
-        """
-        Additional manual backoff loop to handle model cold starts (HF returns 503 while loading).
-        """
-        max_attempts = 8
-        delay = 2.0
-        for attempt in range(1, max_attempts + 1):
-            try:
-                resp = self.session.post(url, headers=self.headers, json=json, timeout=timeout)
-                # If model is loading or rate-limited, wait and retry
-                if resp.status_code in (429, 503):
-                    msg = ""
-                    try:
-                        msg = resp.json().get("error", "")
-                    except Exception:
-                        msg = resp.text[:200]
-                    print(f"⏳ Attempt {attempt}/{max_attempts} - {resp.status_code}: {msg} | waiting {delay:.1f}s")
-                    time.sleep(delay)
-                    delay = min(delay * 1.7, 30.0)
-                    continue
-                return resp
-            except requests.exceptions.RequestException as e:
-                print(f"⚠️ Network issue on attempt {attempt}/{max_attempts}: {e} | waiting {delay:.1f}s")
-                time.sleep(delay)
-                delay = min(delay * 1.7, 30.0)
-        # Final attempt without catching to propagate any error
-        return self.session.post(url, headers=self.headers, json=json, timeout=timeout)
+        # ... keep session/retries as you have ...
 
     def __call__(self, question: str, 
                  max_new_tokens: int = 512, 
@@ -87,12 +38,11 @@ class BasicAgent:
         print(f"📝 Agent received question (preview): {question[:80]}...")
 
         # Prompt formatting for Llama-3 style
-        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"
-        )
         payload = {
-            "inputs": inputs,
+            "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": max_new_tokens,
                 "return_full_text": False,
@@ -103,28 +53,19 @@ class BasicAgent:
 
         try:
             print("🚀 Querying Hugging Face Inference API...")
-            response = self._post_with_retries(self.api_url, json=payload, timeout=16)
-            # Raise if non-2xx after retries
-            response.raise_for_status()
+            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=16)
+            response.raise_for_status()  # Raise an error for bad status codes
             
             result = response.json()
 
-            # Handle HF error payloads
+            # 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, each with "generated_text"
-            answer = ""
-            if isinstance(result, list) and len(result) > 0:
-                # Some models return list of dicts
-                if isinstance(result[0], dict):
-                    answer = result[0].get("generated_text", "")
-                else:
-                    answer = str(result[0])
-            elif isinstance(result, dict) and "generated_text" in result:
-                # Some endpoints may directly return a dict
-                answer = result.get("generated_text", "")
+            # Normal expected case: list of dicts
+            if isinstance(result, list) and result:
+                answer = result[0].get("generated_text", "")
             else:
                 answer = f"Error: Unexpected API response format: {result}"