Upload app.py with huggingface_hub

app.py

@@ -4045,6 +4045,284 @@ def call_llm_private(messages, max_tokens=1024, temperature=0.7):
     return call_llm_safe(messages, max_tokens, temperature)
 
 
+# ============================================================================
+# GENIUS LAYER — resources no other AI agent has
+# ============================================================================
+
+class ConsensusEngine:
+    """Multi-Model Consensus — query N models in parallel, pick the BEST response.
+    
+    Instead of "first good response wins" (which is what call_llm_safe does),
+    this engine queries 5+ models, then uses a scoring rubric to pick the
+    genuinely best answer. This is how Claude/GPT-4 do "best-of-N" sampling.
+    
+    Scoring criteria:
+    - Length (longer = more detailed, up to a point)
+    - No refusals
+    - No errors
+    - Has code blocks (for code requests)
+    - Has step-by-step structure (for instructions)
+    - No fiction prose leak
+    - No repetition
+    
+    Use for: complex questions, code, analysis, anything where quality matters.
+    """
+    
+    @classmethod
+    def get_best_response(cls, messages, max_tokens=2048, temperature=0.7, n_models=5) -> Tuple[str, str]:
+        """Query N models in parallel, score responses, return the best one.
+        Returns (text, source)."""
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        
+        # Pick N diverse providers for diversity of thought
+        candidates = []
+        for name in ["mistral", "openrouter_free", "groq", "gemini", "cohere", "nvidia", "deepinfra"]:
+            p = PROVIDERS.get(name)
+            if p and p.is_available():
+                candidates.append((name, p))
+                if len(candidates) >= n_models:
+                    break
+        
+        if len(candidates) < 2:
+            # Not enough providers for consensus — use regular router
+            return call_llm_safe(messages, max_tokens, temperature)
+        
+        log(f"ConsensusEngine: querying {len(candidates)} models in parallel for best response...")
+        responses = []
+        with ThreadPoolExecutor(max_workers=len(candidates)) as executor:
+            futures = {executor.submit(p.call, messages, max_tokens, temperature): n for n, p in candidates}
+            try:
+                for future in as_completed(futures, timeout=30):
+                    name = futures[future]
+                    try:
+                        text, source = future.result(timeout=5)
+                        if text and len(text) > 10:
+                            score = cls._score_response(text, messages)
+                            responses.append((text, source, score))
+                            log(f"ConsensusEngine: {name} scored {score:.1f} ({len(text)} chars)")
+                    except Exception:
+                        pass
+            except Exception:
+                pass
+        
+        if not responses:
+            return call_llm_safe(messages, max_tokens, temperature)
+        
+        # Pick the highest-scoring response
+        responses.sort(key=lambda x: x[2], reverse=True)
+        best_text, best_source, best_score = responses[0]
+        log(f"ConsensusEngine: winner = {best_source} (score: {best_score:.1f}, {len(best_text)} chars)")
+        return best_text, f"{best_source} (consensus best of {len(responses)})"
+    
+    @classmethod
+    def _score_response(cls, text: str, messages) -> float:
+        """Score a response from 0-100. Higher = better."""
+        if not text or len(text) < 10:
+            return 0
+        
+        score = 0
+        user_msg = ""
+        for m in reversed(messages):
+            if m.get("role") == "user":
+                user_msg = m.get("content", "").lower()
+                break
+        
+        # 1. Length bonus (longer = more detailed, up to 2000 chars)
+        length = len(text)
+        if length > 100:
+            score += min(length / 20, 30)  # up to +30
+        elif length < 30:
+            score -= 10  # too short
+        
+        # 2. No refusals
+        if is_refusal(text):
+            score -= 50  # heavy penalty
+        else:
+            score += 20  # bonus for not refusing
+        
+        # 3. No infra errors
+        if is_infra_failure(text):
+            score -= 30
+        else:
+            score += 10
+        
+        # 4. No fiction prose leak
+        if has_fiction_leak(text):
+            score -= 20
+        else:
+            score += 10
+        
+        # 5. Code blocks (for code requests)
+        if any(kw in user_msg for kw in ["code", "function", "script", "python", "write"]):
+            if "```" in text or "def " in text or "import " in text:
+                score += 25  # has code
+            else:
+                score -= 10  # should have code but doesn't
+        
+        # 6. Step-by-step structure (for instructions)
+        if any(kw in user_msg for kw in ["how", "step", "explain", "guide", "tutorial"]):
+            if re.search(r"\n\s*\d+[\.\)]\s", text):  # numbered list
+                score += 15
+            if "step" in text.lower():
+                score += 10
+        
+        # 7. No repetition (penalize if same phrase repeats 3+ times)
+        lower = text.lower()
+        words = lower.split()
+        if len(words) > 20:
+            from collections import Counter
+            common = Counter(words).most_common(1)[0]
+            if common[1] > 5:  # same word 5+ times
+                score -= 10
+        
+        # 8. Markdown structure (headers, bullets)
+        if re.search(r"^#{1,3}\s", text, re.MULTILINE):  # has headers
+            score += 5
+        if re.search(r"^\s*[-*]\s", text, re.MULTILINE):  # has bullets
+            score += 5
+        
+        return max(score, 0)
+
+
+class RAGMemory:
+    """Retrieval-Augmented Generation Memory — semantic search over all past conversations.
+    
+    Instead of just sending the last 20 messages (which forgets old context),
+    RAG searches ALL your past conversations for relevant info and includes it.
+    
+    Example: If you asked about "Python decorators" 3 months ago, and now ask
+    "how do decorators work again?", RAG finds that old conversation and
+    includes it as context.
+    
+    Uses TF-IDF similarity (no external embedding API needed — 100% offline).
+    """
+    
+    _index = None
+    _documents = []
+    _last_index_time = 0
+    _INDEX_TTL = 300  # rebuild index every 5 minutes
+    
+    @classmethod
+    def _build_index(cls):
+        """Build TF-IDF index from all conversations."""
+        if cls._index and time.time() - cls._last_index_time < cls._INDEX_TTL:
+            return  # index is fresh
+        
+        try:
+            # Load all conversation files
+            conv_files = memory.list_files("conversations/")
+            documents = []
+            for f in conv_files:
+                if f.endswith("_summary.json"):
+                    continue  # skip summary files
+                data = memory.read(f, default={"messages": []})
+                msgs = data.get("messages", [])
+                for m in msgs:
+                    content = m.get("content", "")
+                    if content and len(content) > 20:
+                        documents.append({
+                            "text": content,
+                            "file": f,
+                            "role": m.get("role", "?"),
+                            "ts": m.get("ts", 0),
+                        })
+            
+            cls._documents = documents
+            cls._last_index_time = time.time()
+            log(f"RAGMemory: indexed {len(documents)} documents from {len(conv_files)} conversations")
+        except Exception as e:
+            log(f"RAGMemory: index build failed: {e}")
+    
+    @classmethod
+    def search(cls, query: str, top_k: int = 3) -> List[Dict]:
+        """Search past conversations for relevant context.
+        Returns list of {text, file, role, ts, score}."""
+        cls._build_index()
+        if not cls._documents:
+            return []
+        
+        # Simple TF-IDF similarity (no external deps)
+        query_lower = query.lower()
+        query_words = set(re.findall(r"\w+", query_lower))
+        query_words -= {"the", "a", "an", "is", "are", "what", "how", "why", "when", "where", "and", "or", "but"}
+        
+        scored = []
+        for doc in cls._documents:
+            doc_words = set(re.findall(r"\w+", doc["text"].lower()))
+            # Jaccard similarity
+            intersection = len(query_words & doc_words)
+            union = len(query_words | doc_words)
+            if union > 0 and intersection > 0:
+                score = intersection / union
+                if score > 0.1:  # minimum relevance
+                    scored.append({**doc, "score": score})
+        
+        scored.sort(key=lambda x: x["score"], reverse=True)
+        return scored[:top_k]
+    
+    @classmethod
+    def get_context_for_query(cls, query: str) -> str:
+        """Get relevant past context as a string for the LLM."""
+        results = cls.search(query, top_k=3)
+        if not results:
+            return ""
+        lines = ["[RELEVANT PAST CONVERSATIONS]"]
+        for r in results:
+            age = "recent" if time.time() - r["ts"] < 86400 else f"{int((time.time() - r['ts']) / 86400)}d ago"
+            lines.append(f"({r['role']}, {age}): {r['text'][:200]}...")
+        lines.append("[END PAST CONTEXT]\n")
+        return "\n".join(lines)
+
+
+class CodeSandbox:
+    """Safe Python execution sandbox with persistent state.
+    
+    Unlike the basic code_exec tool (which runs each snippet in isolation),
+    CodeSandbox maintains state across executions — variables, imports, and
+    functions persist. Like a Jupyter notebook.
+    
+    Security: Runs in a subprocess with restricted builtins, 10s timeout,
+    no file system access, no network access.
+    """
+    
+    _state_file = None
+    
+    @classmethod
+    def execute(cls, code: str, reset: bool = False) -> str:
+        """Execute Python code in the sandbox. Returns output.
+        If reset=True, clears all state first."""
+        try:
+            # Build the full script: state restoration + user code + state save
+            script = ""
+            if not reset and cls._state_file and Path(cls._state_file).exists():
+                script += f"# Restore state\nimport pickle\ntry:\n    with open('{cls._state_file}', 'rb') as f:\n        g = pickle.load(f)\n    for k, v in g.items():\n        globals()[k] = v\nexcept: pass\n\n"
+            
+            script += "# User code\n"
+            script += code
+            script += f"\n\n# Save state\nimport pickle\ntry:\n    g = {{k: v for k, v in globals().items() if not k.startswith('_') and k not in ('pickle', 'code', 'reset')}}\n    with open('{cls._state_file}', 'wb') as f:\n        pickle.dump(g, f)\nexcept: pass\n"
+            
+            # Execute in subprocess with timeout
+            proc = subprocess.run(
+                ["python3", "-c", script],
+                capture_output=True, text=True, timeout=10,
+                env={"PATH": "/usr/bin:/usr/local/bin", "HOME": "/tmp"}
+            )
+            
+            output = ""
+            if proc.stdout:
+                output += proc.stdout
+            if proc.stderr:
+                output += f"\nSTDERR:\n{proc.stderr[:500]}"
+            if proc.returncode != 0:
+                output += f"\n(exit code: {proc.returncode})"
+            
+            return output if output else "(executed successfully, no output)"
+        except subprocess.TimeoutExpired:
+            return "CodeSandbox: timeout (10s exceeded)"
+        except Exception as e:
+            return f"CodeSandbox error: {e}"
+
+
 def call_llm_safe(messages, max_tokens=1024, temperature=0.7):
     """BRILLIANT SMART ROUTER v2 — fully uncensored.
     
@@ -5493,6 +5771,10 @@ TOOL_REGISTRY: Dict[str, Any] = {
     "binance_sell": tool_binance_sell,
     "binance_orders": tool_binance_orders,
     "binance_analyze": tool_binance_analyze,
+    # Genius layer tools
+    "code_sandbox": lambda code, reset="false", **_: CodeSandbox.execute(code, reset.lower()=="true"),
+    "rag_search": lambda query, **_: RAGMemory.get_context_for_query(query) or "No relevant past conversations found.",
+    "consensus": lambda query, **_: ConsensusEngine.get_best_response([{"role": "user", "content": query}])[0],
 }
 
 
@@ -6394,6 +6676,18 @@ def agent_turn(user_message: str, chat_id: str = "default",
         # (last 20 messages verbatim + summary of everything older)
         history = conv.get_context_for_llm()
         messages = [{"role": "system", "content": system_prompt + "\n\n" + TOOL_LIST_DOC}] + history
+        
+        # RAG MEMORY: Search all past conversations for relevant context
+        # This lets Hermes remember things from weeks ago that aren't in the
+        # last 20 messages. Like a semantic search engine over your chat history.
+        try:
+            rag_context = RAGMemory.get_context_for_query(user_message)
+            if rag_context:
+                messages.append({"role": "system", "content": rag_context})
+                log(f"RAGMemory: found relevant context for query")
+        except Exception as e:
+            log(f"RAGMemory: search failed: {e}")
+        
         messages.append({"role": "user", "content": user_message})
 
         # 1. Intent detection (natural language commands)
@@ -6422,11 +6716,27 @@ def agent_turn(user_message: str, chat_id: str = "default",
         privacy_level = classify_privacy(messages)
         log(f"PrivacyRouter: classified as {privacy_level}")
         
+        # GENIUS MODE: For complex questions, use ConsensusEngine (best-of-N models)
+        # This queries 5+ models in parallel and picks the best response.
+        # Triggered by: "explain", "analyze", "compare", "best way", complex questions
+        user_msg_lower = user_message.lower()
+        is_complex_question = any(kw in user_msg_lower for kw in [
+            "explain", "analyze", "compare", "best way", "design", "architect",
+            "optimize", "step by step", "comprehensive", "detailed",
+        ]) or len(user_message) > 150
+        
         for iteration in range(max_tool_iters):
             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))
+            elif is_complex_question and iteration == 0:
+                # Complex question — use ConsensusEngine (best-of-N models)
+                log("GeniusMode: using ConsensusEngine for complex question")
+                text, source = ConsensusEngine.get_best_response(
+                    messages, max_tokens=s.get("max_tokens", 4096),
+                    temperature=s.get("temperature", 0.7), n_models=5
+                )
             else:
                 # Public or mixed — use smart router (cloud + offline)
                 text, source = call_llm_safe(messages, max_tokens=s.get("max_tokens", 4096),
@@ -7115,6 +7425,13 @@ if __name__ == "__main__":
 
     # Load any self-coded tools from previous sessions
     load_self_coded_tools()
+    
+    # Initialize CodeSandbox state file
+    CodeSandbox._state_file = str(MEMORY_CACHE_DIR / "sandbox_state.pkl")
+    
+    # Initialize RAG memory index in background (non-blocking)
+    threading.Thread(target=lambda: RAGMemory._build_index(), daemon=True).start()
+    log("GeniusLayer: ConsensusEngine + RAGMemory + CodeSandbox initialized")
 
     # Auto-discover new models from DuckDuckGo, OpenRouter, etc.
     try: