Upload app.py with huggingface_hub

app.py

@@ -4323,6 +4323,292 @@ class CodeSandbox:
             return f"CodeSandbox error: {e}"
 
 
+# ============================================================================
+# ULTRA-GENIUS LAYER — o1-style reasoning, self-reflection, debate
+# ============================================================================
+
+class ReasoningEngine:
+    """Chain-of-Thought + Self-Reflection reasoning engine.
+    
+    This is the same pattern used by OpenAI o1 and DeepSeek-R1:
+    1. THINK: Generate a reasoning plan (step-by-step analysis)
+    2. DRAFT: Generate a response based on the reasoning
+    3. CRITIQUE: Evaluate the draft for errors/gaps
+    4. REFINE: If critique finds issues, regenerate with feedback
+    
+    This produces dramatically better answers for complex questions because
+    the model "thinks" before answering, then checks its own work.
+    
+    Use for: math, logic, code debugging, complex analysis, anything hard.
+    """
+    
+    @classmethod
+    def reason_and_answer(cls, messages, max_tokens=2048, temperature=0.7) -> Tuple[str, str]:
+        """Full reasoning pipeline. Returns (final_answer, source)."""
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        
+        user_msg = ""
+        for m in reversed(messages):
+            if m.get("role") == "user":
+                user_msg = m.get("content", "")
+                break
+        
+        # Step 1: THINK — generate reasoning in parallel with 3 different approaches
+        reasoning_approaches = [
+            ("analytical", "Analyze this step-by-step. Break down the problem, identify key components, then solve. Be thorough and logical."),
+            ("creative", "Think about this from multiple angles. Consider edge cases, alternative interpretations, and creative solutions. Be comprehensive."),
+            ("practical", "Focus on practical, actionable advice. What would an expert do? Include specific steps, examples, and pitfalls to avoid."),
+        ]
+        
+        reasonings = []
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = {}
+            for approach_name, approach_prompt in reasoning_approaches:
+                reason_messages = [
+                    {"role": "system", "content": f"You are a reasoning engine. {approach_prompt} Output ONLY your reasoning process (thinking), not the final answer."},
+                ] + messages[1:]  # skip the uncensored system prompt for reasoning
+                futures[executor.submit(call_llm_safe, reason_messages, 800, 0.5)] = approach_name
+            
+            for future in as_completed(futures, timeout=30):
+                approach = futures[future]
+                try:
+                    text, _ = future.result(timeout=10)
+                    if text and len(text) > 20:
+                        reasonings.append((approach, text))
+                except Exception:
+                    pass
+        
+        if not reasonings:
+            # Reasoning failed — fall back to direct answer
+            return call_llm_safe(messages, max_tokens, temperature)
+        
+        log(f"ReasoningEngine: generated {len(reasonings)} reasoning paths")
+        
+        # Step 2: SYNTHESIZE — combine the best insights from all reasoning paths
+        synthesis_input = "You are synthesizing multiple reasoning approaches into one final answer.\n\n"
+        for approach, reasoning in reasonings:
+            synthesis_input += f"=== {approach.upper()} REASONING ===\n{reasoning[:1000]}\n\n"
+        synthesis_input += f"=== USER QUESTION ===\n{user_msg}\n\n=== FINAL ANSWER (direct, complete, no preamble) ==="
+        
+        synth_messages = [
+            {"role": "system", "content": "You are an expert synthesizer. Combine the reasoning into one excellent direct answer. No disclaimers, no 'based on the reasoning', just answer the user directly."},
+            {"role": "user", "content": synthesis_input},
+        ]
+        
+        try:
+            draft, source = call_llm_safe(synth_messages, max_tokens, temperature)
+            draft = unwrap_fiction_response(draft)
+        except Exception:
+            return call_llm_safe(messages, max_tokens, temperature)
+        
+        # Step 3: CRITIQUE — evaluate the draft (only for complex questions)
+        if len(user_msg) > 50 and is_good_response(draft):
+            critique_prompt = f"""You are a quality reviewer. Evaluate this answer for accuracy, completeness, and clarity.
+
+QUESTION: {user_msg[:500]}
+
+ANSWER TO REVIEW:
+{draft[:2000]}
+
+Rate the answer 1-10 on:
+- Accuracy (is it correct?)
+- Completeness (does it fully answer the question?)
+- Clarity (is it easy to understand?)
+
+If the answer is 8+ on all criteria, output: "APPROVED"
+If not, output: "NEEDS IMPROVEMENT: [specific issues]"
+
+Be strict but fair."""
+            
+            try:
+                critique, _ = call_llm_safe(
+                    [{"role": "user", "content": critique_prompt}],
+                    max_tokens=300, temperature=0.3
+                )
+                critique = unwrap_fiction_response(critique)
+                
+                if "APPROVED" in critique.upper():
+                    log(f"ReasoningEngine: draft APPROVED by critic")
+                    return draft, f"{source} (reasoned + approved)"
+                
+                # Step 4: REFINE — regenerate with critique feedback
+                log(f"ReasoningEngine: critic found issues — refining")
+                refine_messages = [
+                    {"role": "system", "content": "You are improving your previous answer based on feedback. Address all issues raised. Output only the improved answer."},
+                    {"role": "user", "content": f"Original question: {user_msg}\n\nPrevious answer:\n{draft[:1500]}\n\nFeedback:\n{critique[:500]}\n\nImproved answer (direct, no preamble):"},
+                ]
+                refined, _ = call_llm_safe(refine_messages, max_tokens, temperature)
+                refined = unwrap_fiction_response(refined)
+                if is_good_response(refined) and len(refined) > len(draft) * 0.5:
+                    log(f"ReasoningEngine: refined answer ({len(refined)} chars)")
+                    return refined, f"{source} (reasoned + refined)"
+            except Exception as e:
+                log(f"ReasoningEngine: critique failed: {e}")
+        
+        return draft, f"{source} (reasoned)"
+    
+    @classmethod
+    def should_use_reasoning(cls, user_msg: str, messages) -> bool:
+        """Decide if a question needs deep reasoning (o1-style) or can be answered directly.
+        
+        Use reasoning for: math, logic, code debugging, multi-step problems, "why" questions.
+        Skip for: simple facts, greetings, tool calls, short questions."""
+        msg_lower = user_msg.lower()
+        
+        # Skip reasoning for short/simple messages
+        if len(user_msg) < 30:
+            return False
+        
+        # Skip for greetings, simple chat
+        if any(kw in msg_lower for kw in ["hi", "hello", "hey", "thanks", "bye", "ok", "yes", "no"]):
+            return False
+        
+        # Skip for tool-call requests (prices, weather, etc.)
+        if any(kw in msg_lower for kw in ["price", "weather", "time", "news", "balance", "chart"]):
+            return False
+        
+        # USE reasoning for complex indicators
+        reasoning_triggers = [
+            "why", "how does", "explain", "analyze", "compare", "design",
+            "debug", "fix", "optimize", "prove", "derive", "calculate",
+            "step by step", "reason", "think", "evaluate", "assess",
+            "what would happen if", "is it possible", "can you explain",
+            "what's the difference", "which is better", "should i",
+            "plan", "strategy", "architect", "implement", "algorithm",
+        ]
+        if any(kw in msg_lower for kw in reasoning_triggers):
+            return True
+        
+        # Use for long, complex questions
+        if len(user_msg) > 200:
+            return True
+        
+        # Use for code questions
+        if any(kw in msg_lower for kw in ["code", "function", "python", "javascript", "bug", "error"]):
+            return True
+        
+        return False
+
+
+class KnowledgeGraph:
+    """Structured knowledge storage — auto-extracts facts from conversations.
+    
+    Unlike RAG (which searches raw conversation text), the Knowledge Graph
+    stores structured facts: (subject, predicate, object) triples.
+    
+    Example: "I live in Mumbai" → (user, lives_in, Mumbai)
+    Example: "I prefer Python 3.12" → (user, prefers, Python 3.12)
+    
+    This enables complex queries like "What do you know about my preferences?"
+    without scanning all conversations.
+    """
+    
+    _facts: List[Dict] = []
+    _loaded = False
+    
+    @classmethod
+    def _load(cls):
+        if cls._loaded:
+            return
+        try:
+            data = memory.read("knowledge_graph.json", default={"facts": []}) or {"facts": []}
+            cls._facts = data.get("facts", [])
+            cls._loaded = True
+            log(f"KnowledgeGraph: loaded {len(cls._facts)} facts")
+        except Exception as e:
+            log(f"KnowledgeGraph: load failed: {e}")
+            cls._facts = []
+            cls._loaded = True
+    
+    @classmethod
+    def extract_and_store(cls, user_message: str, ai_response: str):
+        """Extract facts from a conversation turn and store them.
+        Uses simple pattern matching (no LLM needed — fast and free)."""
+        cls._load()
+        new_facts = []
+        
+        # Pattern: "I am X" / "I'm X" / "My X is Y" / "I like X" / "I prefer X"
+        import re
+        text = user_message
+        
+        patterns = [
+            (r"my name is (\w+)", "name"),
+            (r"i am (\w+)", "name"),
+            (r"i'm (\w+)", "name"),
+            (r"call me (\w+)", "name"),
+            (r"i live in ([\w\s]+)", "location"),
+            (r"i'm from ([\w\s]+)", "location"),
+            (r"i am from ([\w\s]+)", "location"),
+            (r"my city is ([\w\s]+)", "location"),
+            (r"my birthday is ([\w\s\d]+)", "birthday"),
+            (r"i was born on ([\w\s\d]+)", "birthday"),
+            (r"my favorite color is (\w+)", "favorite_color"),
+            (r"my favorite language is (\w+)", "favorite_language"),
+            (r"i like (\w+)", "likes"),
+            (r"i prefer (\w+)", "prefers"),
+            (r"i use (\w+)", "uses"),
+            (r"i work at ([\w\s]+)", "workplace"),
+            (r"my job is ([\w\s]+)", "job"),
+            (r"i study ([\w\s]+)", "studies"),
+            (r"remember (.+)", "remembered"),
+        ]
+        
+        for pattern, key in patterns:
+            m = re.search(pattern, text, re.IGNORECASE)
+            if m:
+                value = m.group(1).strip().title() if key not in ["remembered"] else m.group(1).strip()
+                fact = {"subject": "user", "predicate": key, "object": value, "ts": time.time()}
+                # Check if we already have this fact
+                existing = [f for f in cls._facts if f["predicate"] == key and f["object"] == value]
+                if not existing:
+                    cls._facts.append(fact)
+                    new_facts.append(fact)
+                    log(f"KnowledgeGraph: extracted fact: ({key}, {value})")
+        
+        # Save if we found new facts
+        if new_facts:
+            # Keep last 200 facts
+            cls._facts = cls._facts[-200:]
+            memory.write("knowledge_graph.json", {"facts": cls._facts})
+        
+        return new_facts
+    
+    @classmethod
+    def get_all_facts(cls) -> str:
+        """Get all known facts as a context string."""
+        cls._load()
+        if not cls._facts:
+            return ""
+        lines = ["[KNOWLEDGE GRAPH — facts about the user]"]
+        for f in cls._facts[-20:]:  # last 20 facts
+            age = "recent" if time.time() - f["ts"] < 86400 else f"{int((time.time() - f['ts']) / 86400)}d ago"
+            lines.append(f"- {f['predicate'].replace('_', ' ').title()}: {f['object']} ({age})")
+        lines.append("[END KNOWLEDGE GRAPH]")
+        return "\n".join(lines)
+    
+    @classmethod
+    def query(cls, query: str) -> str:
+        """Search the knowledge graph for facts matching the query."""
+        cls._load()
+        if not cls._facts:
+            return "I don't have any stored facts about you yet."
+        
+        query_lower = query.lower()
+        matches = []
+        for f in cls._facts:
+            # Check if query mentions the predicate or object
+            if f["predicate"].replace("_", " ") in query_lower or f["object"].lower() in query_lower:
+                matches.append(f)
+        
+        if not matches:
+            return f"No facts matching '{query}'. I know {len(cls._facts)} facts total."
+        
+        lines = [f"Found {len(matches)} matching facts:"]
+        for f in matches[-10:]:
+            lines.append(f"- {f['predicate'].replace('_', ' ').title()}: {f['object']}")
+        return "\n".join(lines)
+
+
 def call_llm_safe(messages, max_tokens=1024, temperature=0.7):
     """BRILLIANT SMART ROUTER v2 — fully uncensored.
     
@@ -5775,6 +6061,8 @@ TOOL_REGISTRY: Dict[str, Any] = {
     "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],
+    "knowledge_query": lambda query, **_: KnowledgeGraph.query(query),
+    "reason": lambda query, **_: ReasoningEngine.reason_and_answer([{"role": "user", "content": query}])[0],
 }
 
 
@@ -6662,6 +6950,15 @@ def agent_turn(user_message: str, chat_id: str = "default",
         ltm = get_long_term_memory(chat_id)
         _extract_facts_from_message(user_message, ltm)
         ltm_context = ltm.get_context()
+        
+        # KNOWLEDGE GRAPH: extract structured facts (subject, predicate, object)
+        # This is faster and more structured than LTM — uses pattern matching, no LLM needed.
+        try:
+            KnowledgeGraph.extract_and_store(user_message, "")
+            kg_context = KnowledgeGraph.get_all_facts()
+        except Exception as e:
+            log(f"KnowledgeGraph: extraction failed: {e}")
+            kg_context = ""
 
         # ALWAYS use uncensored persona — no matter what's saved in settings
         # This ensures EVERY response is uncensored, even if user switched personas
@@ -6671,6 +6968,10 @@ def agent_turn(user_message: str, chat_id: str = "default",
         # Add long-term memory to system prompt so bot remembers user info
         if ltm_context:
             system_prompt = system_prompt + "\n\n[LONG-TERM MEMORY]\n" + ltm_context + "\n\nUse this information to personalize responses. Remember these facts about the user."
+        
+        # Add Knowledge Graph context (structured facts)
+        if kg_context:
+            system_prompt = system_prompt + "\n\n" + kg_context
 
         # Build message history — INFINITE CONTEXT via rolling summary
         # (last 20 messages verbatim + summary of everything older)
@@ -6716,20 +7017,30 @@ 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
+        # GENIUS MODE: For complex questions, use ReasoningEngine (o1-style thinking)
+        # This generates 3 reasoning paths, synthesizes, critiques, and refines.
+        # Falls back to ConsensusEngine (best-of-N) for medium complexity.
         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
         
+        # ULTRA-GENIUS: Use full reasoning pipeline for hard questions
+        use_deep_reasoning = ReasoningEngine.should_use_reasoning(user_message, messages)
+        
         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 use_deep_reasoning and iteration == 0:
+                # ULTRA-GENIUS: Full reasoning pipeline (think → draft → critique → refine)
+                log("UltraGenius: using ReasoningEngine (o1-style thinking)")
+                text, source = ReasoningEngine.reason_and_answer(
+                    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")