Upload quant_llm.py with huggingface_hub

quant_llm.py

@@ -1,76 +1,59 @@
 """
 QuantAgent OS - LLM Adapter Layer
 Provides unified multi-model intelligence:
-- Google Gemini (gemini-2.0-flash, gemini-1.5-flash via google.genai / google.generativeai)
+- Google Gemini (gemini-2.0-flash, gemini-1.5-flash via lightweight direct REST API)
 - Fallback Autonomous Expert Quantitative Rule-Engine (Zero-configuration out of the box)
 """
 
 import os
 import re
+import json
 import logging
+import requests
 from typing import Optional, Dict, Any
 
 logger = logging.getLogger(__name__)
 
 
 class LLMAdapter:
-    """Unified LLM client with intelligent fallback."""
+    """Unified LLM client with direct REST connection and intelligent fallback."""
 
     def __init__(self, api_key: Optional[str] = None, model_name: str = "gemini-2.0-flash"):
         self.api_key = api_key or os.environ.get("GEMINI_API_KEY")
         self.model_name = model_name
-        self._client = None
-        self._init_client()
-
-    def _init_client(self):
-        if not self.api_key:
-            return
-
-        # Try modern google.genai first
-        try:
-            from google import genai
-            self._client = genai.Client(api_key=self.api_key)
-            self._backend = "genai"
-            logger.info("Initialized modern google.genai client.")
-            return
-        except Exception:
-            pass
-
-        # Try google.generativeai fallback
-        try:
-            import google.generativeai as gai
-            gai.configure(api_key=self.api_key)
-            self._client = gai.GenerativeModel(self.model_name)
-            self._backend = "generativeai"
-            logger.info("Initialized google.generativeai client.")
-            return
-        except Exception as e:
-            logger.warning(f"Could not initialize Gemini SDK: {e}")
-            self._client = None
-            self._backend = "expert_heuristics"
 
     def update_key(self, api_key: str):
         self.api_key = api_key.strip()
-        self._init_client()
 
     def is_live_llm(self) -> bool:
-        return self._client is not None
+        return bool(self.api_key)
 
     def generate(self, prompt: str, temperature: float = 0.3) -> str:
-        """Generates text completion with automated fallback."""
-        if self._client is not None:
+        """Generates text completion via Google Gemini REST API with automated fallback."""
+        if self.api_key:
             try:
-                if self._backend == "genai":
-                    response = self._client.models.generate_content(
-                        model=self.model_name,
-                        contents=prompt,
-                    )
-                    return response.text
-                elif self._backend == "generativeai":
-                    response = self._client.generate_content(prompt)
-                    return response.text
+                # Direct Google AI Studio REST endpoint (no heavy dependencies)
+                url = f"https://generativelanguage.googleapis.com/v1beta/models/{self.model_name}:generateContent?key={self.api_key}"
+                headers = {"Content-Type": "application/json"}
+                payload = {
+                    "contents": [{"parts": [{"text": prompt}]}],
+                    "generationConfig": {
+                        "temperature": temperature,
+                        "maxOutputTokens": 2048
+                    }
+                }
+                response = requests.post(url, headers=headers, json=payload, timeout=20)
+                if response.status_code == 200:
+                    data = response.json()
+                    candidates = data.get("candidates", [])
+                    if candidates:
+                        parts = candidates[0].get("content", {}).get("parts", [])
+                        if parts:
+                            return parts[0].get("text", "")
+                else:
+                    logger.warning(f"Gemini API returned status {response.status_code}: {response.text}")
             except Exception as e:
-                logger.error(f"Gemini API generation error: {e}. Falling back to internal engine.")
+                logger.error(f"Gemini API REST error: {e}. Falling back to internal expert engine.")
 
         # Autonomous Quant Expert Engine Fallback
         return self._autonomous_quant_fallback(prompt)