Upload app.py with huggingface_hub

app.py

@@ -3665,13 +3665,15 @@ class OfflineLLMProvider(LLMProvider):
     _tokenizer = None
     _loading = False
     
-    MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"  # Tiny, fast, CPU-friendly
+    MODEL_NAME = os.environ.get("OFFLINE_MODEL", "Qwen/Qwen2.5-7B-Instruct")  # Smart enough for trading
+    # Fallback to 0.5B if 7B fails to load (not enough RAM)
+    FALLBACK_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
     
     def is_available(self) -> bool:
         return True  # Always available
     
     def _load_model(self):
-        """Load the offline model using transformers."""
+        """Load the offline model using transformers. Tries 7B first, falls back to 0.5B."""
         if self._model:
             return True
         if self._loading:
@@ -3682,19 +3684,33 @@ class OfflineLLMProvider(LLMProvider):
             import torch
             from transformers import AutoModelForCausalLM, AutoTokenizer
             
-            log(f"OfflineLLM: loading {self.MODEL_NAME}...")
-            self._tokenizer = AutoTokenizer.from_pretrained(
-                self.MODEL_NAME, trust_remote_code=True
-            )
-            self._model = AutoModelForCausalLM.from_pretrained(
-                self.MODEL_NAME,
-                torch_dtype=torch.float32,  # CPU
-                device_map="cpu",
-                trust_remote_code=True,
-            )
-            log(f"OfflineLLM: model loaded successfully!")
+            # Try 7B first (smart enough for trading analysis)
+            for model_name in [self.MODEL_NAME, self.FALLBACK_MODEL]:
+                try:
+                    log(f"OfflineLLM: loading {model_name}...")
+                    self._tokenizer = AutoTokenizer.from_pretrained(
+                        model_name, trust_remote_code=True
+                    )
+                    # Use bfloat16 for 7B to save RAM, float32 for 0.5B
+                    dtype = torch.bfloat16 if "7B" in model_name else torch.float32
+                    self._model = AutoModelForCausalLM.from_pretrained(
+                        model_name,
+                        torch_dtype=dtype,
+                        device_map="cpu",
+                        trust_remote_code=True,
+                        low_cpu_mem_usage=True,
+                    )
+                    log(f"OfflineLLM: {model_name} loaded successfully!")
+                    self.MODEL_NAME = model_name  # remember which one worked
+                    self._loading = False
+                    return True
+                except Exception as e:
+                    log(f"OfflineLLM: {model_name} failed ({str(e)[:100]}) — trying fallback")
+                    continue
+            
+            # Both failed
             self._loading = False
-            return True
+            return False
         except ImportError:
             log("OfflineLLM: transformers/torch not installed, using Pollinations fallback")
             self._loading = False
@@ -3917,6 +3933,118 @@ class Settings:
 settings = Settings("default")
 
 
+# ============================================================================
+# PRIVACY ROUTER — keeps personal/financial data on offline model only
+# ============================================================================
+
+# Keywords that indicate PRIVATE data (account info, balances, trades, API keys)
+# These requests MUST be handled by the offline model — no data leaves your Space.
+PRIVATE_KEYWORDS = [
+    # Binance account data
+    "my balance", "my wallet", "my portfolio", "my positions", "my funds",
+    "my binance", "my account", "my orders", "my trades", "my holdings",
+    "binance balance", "binance account", "binance orders", "binance wallet",
+    # Trade execution
+    "buy ", "sell ", "place order", "execute trade", "make trade",
+    "buy btc", "sell btc", "buy eth", "sell eth",
+    # API keys / credentials
+    "api key", "api secret", "my key", "my secret", "password", "credentials",
+    # VPS / SSH
+    "my vps", "my server", "ssh connect", "ssh run",
+    # Personal info
+    "my name", "my location", "my birthday", "my address", "my phone",
+    "my email", "my credit card", "my bank",
+]
+
+# Keywords that indicate PUBLIC data (market prices, charts, news)
+# These can be sent to cloud models — it's just public market data.
+PUBLIC_KEYWORDS = [
+    "price of", "btc price", "eth price", "current price", "market price",
+    "chart", "candlestick", "24h stats", "market cap", "volume",
+    "news", "headline", "latest news",
+    "weather", "temperature",
+    "wikipedia", "what is", "explain", "how does",
+    "write code", "write a", "create a", "build a",
+]
+
+
+def classify_privacy(messages) -> str:
+    """Classify a request as PRIVATE, PUBLIC, or MIXED.
+    
+    PRIVATE = account data, trades, API keys → offline model ONLY
+    PUBLIC = market prices, charts, news → cloud models OK
+    MIXED = both (e.g., "analyze my BTC position") → offline for final decision
+    
+    Returns: 'PRIVATE', 'PUBLIC', or 'MIXED'
+    """
+    # Get the last user message
+    user_msg = ""
+    for m in reversed(messages):
+        if m.get("role") == "user":
+            user_msg = m.get("content", "").lower()
+            break
+    if not user_msg:
+        return "PUBLIC"
+    
+    # Check for private keywords
+    has_private = any(kw in user_msg for kw in PRIVATE_KEYWORDS)
+    # Check for public keywords
+    has_public = any(kw in user_msg for kw in PUBLIC_KEYWORDS)
+    
+    if has_private and has_public:
+        return "MIXED"
+    if has_private:
+        return "PRIVATE"
+    return "PUBLIC"
+
+
+def call_llm_private(messages, max_tokens=1024, temperature=0.7):
+    """Call LLM with STRICT privacy — only uses the offline model.
+    NO data leaves your Space. Used for: balances, orders, trades, API keys.
+    
+    Falls back to Pollinations (with fiction-wrap) ONLY if offline model fails
+    AND the request isn't truly sensitive (no API keys in the message)."""
+    user_msg = ""
+    for m in reversed(messages):
+        if m.get("role") == "user":
+            user_msg = m.get("content", "")
+            break
+    
+    log(f"PrivateRouter: handling PRIVATE request ({len(user_msg)} chars) — offline only")
+    
+    # Try offline model FIRST and ONLY (no cloud providers)
+    offline = PROVIDERS.get("offline")
+    if offline and offline.is_available():
+        try:
+            text, source = offline.call(messages, max_tokens, temperature)
+            text = unwrap_fiction_response(text)
+            if is_good_response(text):
+                log(f"PrivateRouter: offline model responded ({len(text)} chars) — 100% private")
+                return text, source + " (PRIVATE — offline only)"
+            else:
+                log(f"PrivateRouter: offline model returned bad response")
+        except Exception as e:
+            log(f"PrivateRouter: offline model failed: {e}")
+    
+    # CRITICAL: If the message contains API keys or secrets, NEVER send to cloud
+    import re
+    has_secret = bool(re.search(r"\b[A-Za-z0-9]{64}\b", user_msg))
+    if has_secret:
+        log("PrivateRouter: REFUSING to send API key to cloud — returning error")
+        return (
+            "I can't process this request right now because the offline model "
+            "is unavailable, and your message contains sensitive data (API key/secret) "
+            "that I won't send to cloud providers. Please try again in a moment — "
+            "the offline model will load shortly.",
+            "PRIVATE — offline unavailable (refused cloud for safety)"
+        )
+    
+    # For non-secret private requests (like "my balance"), fall back to cloud
+    # but strip any account-specific data first
+    log("PrivateRouter: offline unavailable, falling back to cloud (no secrets in message)")
+    return call_llm_safe(messages, max_tokens, temperature)
+
+
 def call_llm_safe(messages, max_tokens=1024, temperature=0.7):
     """BRILLIANT SMART ROUTER v2 — fully uncensored.
     
@@ -5310,12 +5438,15 @@ Give a brief analysis (5-7 sentences):
 
 Be direct and specific. No disclaimers."""
         
-        text, source = call_llm_safe(
+        # Use PRIVATE routing (offline model) so your trading analysis
+        # stays on your Space — no cloud provider sees your positions/strategy.
+        # The chart data itself is public, but the analysis/recommendation is private.
+        text, source = call_llm_private(
             [{"role": "user", "content": analysis_prompt}],
             max_tokens=500, temperature=0.3
         )
         text = unwrap_fiction_response(text)
-        return f"📊 {symbol.upper()} Analysis ({interval}):\n\n{text}"
+        return f"📊 {symbol.upper()} Analysis ({interval}, PRIVATE — offline model):\n\n{text}"
     except Exception as e:
         return f"binance_analyze error: {e}"
 
@@ -6284,9 +6415,22 @@ def agent_turn(user_message: str, chat_id: str = "default",
         # max_tokens default raised to 4096 for fuller uncensored responses
         accumulated_text = ""
         image_path = None
+        
+        # PRIVACY ROUTING: classify the request and route accordingly
+        # PRIVATE (balances, trades, API keys) → offline model ONLY (100% private)
+        # PUBLIC (prices, charts, news, code) → cloud models OK (smart + fast)
+        privacy_level = classify_privacy(messages)
+        log(f"PrivacyRouter: classified as {privacy_level}")
+        
         for iteration in range(max_tool_iters):
-            text, source = call_llm_safe(messages, max_tokens=s.get("max_tokens", 4096),
-                                          temperature=s.get("temperature", 0.7))
+            if privacy_level == "PRIVATE":
+                # Private request — use offline model only, no cloud
+                text, source = call_llm_private(messages, max_tokens=s.get("max_tokens", 4096),
+                                                temperature=s.get("temperature", 0.7))
+            else:
+                # Public or mixed — use smart router (cloud + offline)
+                text, source = call_llm_safe(messages, max_tokens=s.get("max_tokens", 4096),
+                                              temperature=s.get("temperature", 0.7))
             # UNWRAP: extract the direct answer from <ANSWER> tags if present.
             # This converts "The lab hummed... <ANSWER>Here's how to do it...</ANSWER>"
             # into just "Here's how to do it..." so the user sees a normal response.