Upload folder using huggingface_hub

hf_model.py

@@ -1,66 +1,99 @@
 # -*- coding: utf-8 -*-
 """
-HuggingFace Inference API Model Wrapper
-Uses HuggingFace InferenceClient with text_generation (more compatible than chat.completions).
+HF Inference wrapper for Hugging Face Spaces.
+
+Fixes StopIteration (empty provider list) by:
+1) Forcing provider="hf-inference" in InferenceClient
+2) Fallback to HF Router OpenAI-compatible endpoint if needed
+
+Notes:
+- Make sure you ACCEPT Gemma license on Hugging Face with the same account as HF_TOKEN.
+- Add HF_TOKEN in Space Settings -> Secrets.
 """
 
 import os
 import traceback
-from typing import List, Dict
+from typing import List, Dict, Optional
 
+import httpx
 from huggingface_hub import InferenceClient
 
-# ---- Config ----
+
 HF_TOKEN = os.getenv("HF_TOKEN")
 MODEL_ID = os.getenv("MODEL_ID", "google/gemma-3-4b-it")
 
-# Initialize client (bind model here so calls don't need model=...)
-client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+# Force HF provider (instead of provider="auto")
+client = InferenceClient(model=MODEL_ID, token=HF_TOKEN, provider="hf-inference")
 
 
 def _messages_to_prompt(messages: List[Dict]) -> str:
-    """
-    Convert OpenAI-style messages (role/content) to a simple prompt.
-    This is a generic format that works with text-generation endpoints.
-    """
+    """Convert role/content messages into a simple prompt."""
     parts = []
     for m in messages:
         role = (m.get("role") or "user").lower()
         content = m.get("content") or ""
-
         if role == "system":
             parts.append(f"System: {content}")
         elif role == "assistant":
             parts.append(f"Assistant: {content}")
         else:
             parts.append(f"User: {content}")
-
     parts.append("Assistant:")
     return "\n".join(parts)
 
 
+def _router_chat_completion(
+    messages: List[Dict],
+    max_tokens: int,
+    temperature: float,
+) -> str:
+    """
+    Fallback: call HF Router (OpenAI-compatible) endpoint.
+
+    Endpoint format (hf-inference route):
+    https://router.huggingface.co/hf-inference/models/{MODEL_ID}/v1/chat/completions
+    """
+    if not HF_TOKEN:
+        return "Error: HF_TOKEN is not set. Add it in Space Settings -> Secrets."
+
+    url = f"https://router.huggingface.co/hf-inference/models/{MODEL_ID}/v1/chat/completions"
+
+    payload = {
+        "model": MODEL_ID,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "temperature": temperature,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}",
+        "Content-Type": "application/json",
+    }
+
+    with httpx.Client(timeout=60) as http:
+        r = http.post(url, headers=headers, json=payload)
+        r.raise_for_status()
+        data = r.json()
+
+    return data["choices"][0]["message"]["content"].strip()
+
+
 def generate_response(
     messages: List[Dict],
     max_tokens: int = 512,
     temperature: float = 0.7,
 ) -> str:
     """
-    Generate response using HF Inference API via text_generation.
-
-    Args:
-        messages: List of message dicts with 'role' and 'content'
-        max_tokens: Maximum new tokens to generate
-        temperature: Sampling temperature
-
-    Returns:
-        Generated text response (or detailed error)
+    Main generation function.
+    1) Try HF InferenceClient.text_generation with provider="hf-inference"
+    2) If StopIteration / provider issues happen, fallback to HF Router chat completions
     """
     try:
         if not HF_TOKEN:
             return "Error: HF_TOKEN is not set. Add it in Space Settings -> Secrets."
 
+        # Try text-generation (broadly supported)
         prompt = _messages_to_prompt(messages)
-
         out = client.text_generation(
             prompt,
             max_new_tokens=max_tokens,
@@ -68,10 +101,18 @@ def generate_response(
             do_sample=True,
             return_full_text=False,
         )
-
-        # InferenceClient.text_generation returns a string
         return out.strip()
 
+    except StopIteration:
+        # Provider list empty: try router fallback
+        try:
+            return _router_chat_completion(messages, max_tokens=max_tokens, temperature=temperature)
+        except Exception as e2:
+            return (
+                "Error: StopIteration() and router fallback failed.\n\n"
+                f"Fallback error: {repr(e2)}\n\n{traceback.format_exc()}"
+            )
+
     except Exception as e:
         return f"Error: {repr(e)}\n\n{traceback.format_exc()}"
 
@@ -96,10 +137,7 @@ def calculate_expression(expression: str) -> str:
 
     try:
         expr = expression.strip()
-
-        # Allow only digits/operators/parentheses/spaces/dots and ** for power
         if not re.match(r"^[\d\s\+\-\*\/\.\(\)\^]+$", expr.replace("**", "^")):
-            # If it's not a pure math string, bail out gracefully
             return "Calculation error: invalid characters in expression."
 
         result = eval(expr, {"__builtins__": {}}, allowed_names)