Upload folder using huggingface_hub

hf_model.py

@@ -1,66 +1,109 @@
+# -*- coding: utf-8 -*-
 """
 HuggingFace Inference API Model Wrapper
-Uses Gemma 3 27B for fintech orchestrator
+Uses HuggingFace InferenceClient with text_generation (more compatible than chat.completions).
 """
 
 import os
+import traceback
+from typing import List, Dict
+
 from huggingface_hub import InferenceClient
 
-# Initialize client
+# ---- Config ----
 HF_TOKEN = os.getenv("HF_TOKEN")
-MODEL_ID = "google/gemma-3-4b-it"  # Gemma 3 27B Instruct
+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)
+
+
+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.
+    """
+    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}")
 
-client = InferenceClient(token=HF_TOKEN)
+    parts.append("Assistant:")
+    return "\n".join(parts)
 
 
 def generate_response(
-    messages: list[dict],
-    max_tokens: int = 1024,
+    messages: List[Dict],
+    max_tokens: int = 512,
     temperature: float = 0.7,
 ) -> str:
     """
-    Generate response using HuggingFace Inference API.
-    
+    Generate response using HF Inference API via text_generation.
+
     Args:
         messages: List of message dicts with 'role' and 'content'
-        max_tokens: Maximum tokens to generate
+        max_tokens: Maximum new tokens to generate
         temperature: Sampling temperature
-    
+
     Returns:
-        Generated text response
+        Generated text response (or detailed error)
     """
     try:
-        response = client.chat.completions.create(
-            model=MODEL_ID,
-            messages=messages,
-            max_tokens=max_tokens,
+        if not HF_TOKEN:
+            return "Error: HF_TOKEN is not set. Add it in Space Settings -> Secrets."
+
+        prompt = _messages_to_prompt(messages)
+
+        out = client.text_generation(
+            prompt,
+            max_new_tokens=max_tokens,
             temperature=temperature,
+            do_sample=True,
+            return_full_text=False,
         )
-        return response.choices[0].message.content
+
+        # InferenceClient.text_generation returns a string
+        return out.strip()
+
     except Exception as e:
         return f"Error: {repr(e)}\n\n{traceback.format_exc()}"
 
+
 def calculate_expression(expression: str) -> str:
-    """Simple calculator for financial expressions."""
+    """Simple calculator for financial expressions (safe eval)."""
     import re
     import math
-    
-    # Safe eval with limited functions
+
     allowed_names = {
-        'abs': abs, 'round': round, 'min': min, 'max': max,
-        'pow': pow, 'sqrt': math.sqrt, 'log': math.log,
-        'exp': math.exp, 'pi': math.pi, 'e': math.e,
+        "abs": abs,
+        "round": round,
+        "min": min,
+        "max": max,
+        "pow": pow,
+        "sqrt": math.sqrt,
+        "log": math.log,
+        "exp": math.exp,
+        "pi": math.pi,
+        "e": math.e,
     }
-    
+
     try:
-        # Clean the expression
         expr = expression.strip()
-        # Basic validation
-        if not re.match(r'^[\d\s\+\-\*\/\.\(\)\^]+$', expr.replace('**', '^')):
-            # Try to extract numbers and operators more flexibly
-            pass
-        
+
+        # 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)
         return f"{result:,.2f}"
+
     except Exception as e:
         return f"Calculation error: {str(e)}"