fix the errors

model_client.py

@@ -1,7 +1,10 @@
-import requests
-from typing import Optional, Tuple
+from typing import Tuple
+
+from huggingface_hub import InferenceClient
+
 from config import settings
 
+
 class ModelClient:
     def __init__(self):
         self.primary_model = settings.PRIMARY_CODE_MODEL
@@ -9,71 +12,52 @@ class ModelClient:
         self.timeout = settings.MODEL_TIMEOUT_SECONDS
         self.temperature = settings.DEFAULT_TEMPERATURE
         self.top_p = settings.DEFAULT_TOP_P
+        self.hf_token = getattr(settings, "HUGGINGFACE_API_TOKEN", "")
 
-    def _build_payload(self, prompt: str, model_name: str) -> dict:
-        return {
-            "inputs": prompt,
-            "parameters": {
-                "temperature": self.temperature,
-                "top_p": self.top_p,
-                "return_full_text": False,
-            },
-            "options": {
-                "wait_for_model": True,
-                "use_cache": False,
-            }
-        }
-
-    def _extract_text(self, response_json) -> str:
-        if isinstance(response_json, list) and len(response_json) > 0:
-            first_item = response_json
-            if isinstance(first_item, dict) and "generated_text" in first_item:
-                return str(first_item["generated_text"]).strip()
-        
-        if isinstance(response_json, dict):
-            if "generated_text" in response_json:
-                return str(response_json["generated_text"]).strip()
-            if "error" in response_json:
-                raise RuntimeError(str(response_json["error"]).strip())
-        
-        raise RuntimeError("Invalid model response format.")
+    def _create_client(self) -> InferenceClient:
+        return InferenceClient(
+            api_key=self.hf_token if self.hf_token else None,
+            timeout=self.timeout,
+        )
 
-    def _call_huggingface_model(self, prompt: str, model_name: str) -> str:
-    
-        api_url = f"https://api-inference.huggingface.co/models/{model_name}"
-        
-        headers = {}
-        hf_token = getattr(settings, "HUGGINGFACE_API_TOKEN", "")
-        if hf_token:
-            headers["Authorization"] = f"Bearer {hf_token}"
+    def _call_model(self, prompt: str, model_name: str) -> str:
+        client = self._create_client()
+
+        response = client.chat.completions.create(
+            model=model_name,
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            temperature=self.temperature,
+            top_p=self.top_p,
+            max_tokens=1200,
+        )
 
-        payload = self._build_payload(prompt, model_name)
+        if not response or not response.choices:
+            raise RuntimeError("Empty response from model.")
 
-        response = requests.post(
-            api_url,
-            headers=headers,
-            json=payload,
-            timeout=self.timeout,
-        )
-        
-       
-        if response.status_code == 404 or "no longer supported" in response.text:
-             api_url = f"https://api-inference.huggingface.co/models/{model_name}" 
+        message = response.choices[0].message
+        if not message or not message.content:
+            raise RuntimeError("Model returned no content.")
 
-        response.raise_for_status()
-        return self._extract_text(response.json())
+        return str(message.content).strip()
 
     def generate(self, prompt: str) -> Tuple[str, str, bool]:
         try:
-            output = self._call_huggingface_model(prompt, self.primary_model)
+            output = self._call_model(prompt, self.primary_model)
             return output, self.primary_model, False
         except Exception as primary_error:
             print(f"Primary model failed: {primary_error}")
+
             try:
-                output = self._call_huggingface_model(prompt, self.fallback_model)
+                output = self._call_model(prompt, self.fallback_model)
                 return output, self.fallback_model, True
             except Exception as fallback_error:
                 print(f"Fallback model failed: {fallback_error}")
-                raise RuntimeError(f"Both primary and fallback models failed.")
+                raise RuntimeError("Both primary and fallback models failed.")
+
 
 model_client = ModelClient()