Upload app.py with huggingface_hub

app.py

@@ -4609,6 +4609,413 @@ class KnowledgeGraph:
         return "\n".join(lines)
 
 
+# ============================================================================
+# APEX-GENIUS LAYER — multi-agent debate, self-improvement, verification
+# ============================================================================
+
+class MultiAgentDebate:
+    """Multi-Agent Debate System — 3 agents with different viewpoints argue,
+    then a moderator synthesizes the best answer.
+    
+    This produces higher-quality answers than single-model reasoning because:
+    - Agent 1 (Optimist) argues for the best approach
+    - Agent 2 (Skeptic) challenges assumptions and finds flaws
+    - Agent 3 (Pragmatist) focuses on practical implementation
+    - Moderator synthesizes the debate into one excellent answer
+    
+    Use for: important decisions, controversial topics, architecture choices.
+    """
+    
+    AGENTS = [
+        ("Optimist", "You are an optimistic expert. Argue for the BEST possible approach. Be enthusiastic about the potential. Highlight advantages and opportunities."),
+        ("Skeptic", "You are a skeptical critic. Challenge every assumption. Find flaws, risks, edge cases, and failure modes. Be rigorous and demanding."),
+        ("Pragmatist", "You are a practical engineer. Focus on what ACTUALLY works in production. Consider cost, time, maintainability, and real-world constraints."),
+    ]
+    
+    @classmethod
+    def debate(cls, messages, max_tokens=2048) -> Tuple[str, str]:
+        """Run a 3-agent debate and synthesize the result."""
+        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
+        
+        # Round 1: Each agent gives their initial position
+        log("DebateEngine: Round 1 — agents giving initial positions...")
+        positions = []
+        with ThreadPoolExecutor(max_workers=3) as executor:
+            futures = {}
+            for agent_name, agent_prompt in cls.AGENTS:
+                debate_messages = [
+                    {"role": "system", "content": f"{agent_prompt} Answer directly. No disclaimers."},
+                ] + messages[1:]
+                futures[executor.submit(call_llm_safe, debate_messages, 1000, 0.7)] = agent_name
+            
+            for future in as_completed(futures, timeout=30):
+                agent = futures[future]
+                try:
+                    text, _ = future.result(timeout=10)
+                    if text and len(text) > 20:
+                        positions.append((agent, text))
+                except Exception:
+                    pass
+        
+        if len(positions) < 2:
+            return call_llm_safe(messages, max_tokens, 0.7)
+        
+        # Round 2: Moderator synthesizes
+        log(f"DebateEngine: Round 2 — moderator synthesizing {len(positions)} positions...")
+        moderator_input = f"You are a moderator. Synthesize these 3 expert perspectives into ONE excellent answer.\n\n"
+        moderator_input += f"QUESTION: {user_msg[:500]}\n\n"
+        for agent, position in positions:
+            moderator_input += f"=== {agent.upper()} POSITION ===\n{position[:800]}\n\n"
+        moderator_input += "=== FINAL SYNTHESIZED ANSWER (direct, complete, incorporates best insights from all 3) ==="
+        
+        try:
+            final, source = call_llm_safe(
+                [{"role": "user", "content": moderator_input}],
+                max_tokens, 0.5
+            )
+            final = unwrap_fiction_response(final)
+            return final, f"{source} (debate: {len(positions)} agents)"
+        except Exception:
+            return positions[0][1], f"DebateEngine (agent: {positions[0][0]})"
+
+
+class SelfImprovement:
+    """Self-Improvement Loop — learns from user feedback.
+    
+    Tracks:
+    - Which response styles get "thanks" / "great" / "perfect" (positive)
+    - Which get "no" / "wrong" / "try again" (negative)
+    - Adjusts future responses based on patterns
+    
+    Also tracks:
+    - Response length preferences
+    - Tone preferences (formal vs casual)
+    - Topics the user cares about
+    """
+    
+    _feedback: Dict[str, Any] = {}
+    _loaded = False
+    
+    @classmethod
+    def _load(cls):
+        if cls._loaded:
+            return
+        try:
+            data = memory.read("self_improvement.json", default={}) or {}
+            cls._feedback = data
+            cls._loaded = True
+        except Exception:
+            cls._feedback = {"positive": 0, "negative": 0, "patterns": {}, "adjustments": {}}
+            cls._loaded = True
+    
+    @classmethod
+    def record_feedback(cls, user_message: str, ai_response: str, next_user_message: str):
+        """Analyze the user's NEXT message for feedback signals.
+        
+        Positive: 'thanks', 'great', 'perfect', 'awesome', 'good', 'nice'
+        Negative: 'no', 'wrong', 'try again', 'bad', 'terrible', 'not what I meant'
+        """
+        cls._load()
+        next_lower = next_user_message.lower().strip()
+        
+        positive_signals = ["thanks", "thank you", "great", "perfect", "awesome", "good", "nice",
+                           "exactly", "that's right", "correct", "yes", "👍", "love it", "amazing"]
+        negative_signals = ["no", "wrong", "try again", "bad", "terrible", "not what",
+                           "that's not", "incorrect", "nope", "didn't work", "doesn't work",
+                           "error", "failed", "broken"]
+        
+        is_positive = any(sig in next_lower for sig in positive_signals)
+        is_negative = any(sig in next_lower for sig in negative_signals)
+        
+        if is_positive and not is_negative:
+            cls._feedback["positive"] = cls._feedback.get("positive", 0) + 1
+            # Learn: what made this response good?
+            resp_len = len(ai_response)
+            cls._feedback.setdefault("good_lengths", []).append(resp_len)
+            # Track style
+            if "```" in ai_response:
+                cls._feedback["code_appreciated"] = cls._feedback.get("code_appreciated", 0) + 1
+            if re.search(r"\n\s*\d+\.", ai_response):
+                cls._feedback["numbered_lists_appreciated"] = cls._feedback.get("numbered_lists_appreciated", 0) + 1
+            log(f"SelfImprovement: recorded POSITIVE feedback (total: {cls._feedback['positive']})")
+        elif is_negative and not is_positive:
+            cls._feedback["negative"] = cls._feedback.get("negative", 0) + 1
+            cls._feedback.setdefault("bad_lengths", []).append(len(ai_response))
+            log(f"SelfImprovement: recorded NEGATIVE feedback (total: {cls._feedback['negative']})")
+        
+        # Save
+        try:
+            memory.write("self_improvement.json", cls._feedback)
+        except Exception:
+            pass
+    
+    @classmethod
+    def get_adjustments(cls) -> str:
+        """Get learned adjustments as a system prompt addition."""
+        cls._load()
+        pos = cls._feedback.get("positive", 0)
+        neg = cls._feedback.get("negative", 0)
+        if pos + neg < 3:
+            return ""  # not enough data
+        
+        adjustments = []
+        # Length preference
+        good_lengths = cls._feedback.get("good_lengths", [])
+        bad_lengths = cls._feedback.get("bad_lengths", [])
+        if len(good_lengths) >= 2:
+            avg_good = sum(good_lengths) / len(good_lengths)
+            adjustments.append(f"Aim for responses around {int(avg_good)} chars (user prefers this length).")
+        
+        # Style preferences
+        if cls._feedback.get("code_appreciated", 0) > 2:
+            adjustments.append("User appreciates code examples — include them when relevant.")
+        if cls._feedback.get("numbered_lists_appreciated", 0) > 2:
+            adjustments.append("User appreciates numbered lists for instructions.")
+        
+        # Satisfaction rate
+        total = pos + neg
+        satisfaction = pos / total * 100 if total > 0 else 0
+        adjustments.append(f"User satisfaction: {satisfaction:.0f}% ({pos} positive, {neg} negative).")
+        
+        return "\n[SELF-IMPROVEMENT ADJUSTMENTS]\n" + "\n".join(adjustments) if adjustments else ""
+
+
+class CodeVerifier:
+    """Code Verification — automatically runs generated code to verify it works.
+    
+    After the LLM generates code, CodeVerifier:
+    1. Extracts code blocks from the response
+    2. Runs each block in the sandbox
+    3. If code fails, sends the error back to the LLM for fixing
+    4. Returns the verified (working) code
+    
+    This eliminates the #1 complaint about AI code: "it doesn't work."
+    """
+    
+    @classmethod
+    def verify_and_fix(cls, response: str, user_request: str) -> str:
+        """Extract code from response, run it, fix if broken. Returns verified response."""
+        # Extract Python code blocks
+        code_blocks = re.findall(r"```(?:python)?\n(.*?)```", response, re.DOTALL)
+        if not code_blocks:
+            return response  # no code to verify
+        
+        # Only verify if it looks like executable code (not just snippets)
+        executable_blocks = []
+        for block in code_blocks:
+            # Skip if it's just a variable or single line
+            if len(block.strip().split("\n")) >= 2 or "def " in block or "import " in block:
+                executable_blocks.append(block)
+        
+        if not executable_blocks:
+            return response
+        
+        log(f"CodeVerifier: found {len(executable_blocks)} executable code blocks to verify")
+        
+        fixed_blocks = []
+        for i, code in enumerate(executable_blocks):
+            # Try running it
+            result = CodeSandbox.execute(code, reset=True)
+            
+            if "error" in result.lower() or "Traceback" in result or "SyntaxError" in result:
+                log(f"CodeVerifier: block {i+1} FAILED — attempting fix")
+                # Ask LLM to fix the code
+                fix_prompt = f"""The following Python code has an error. Fix it.
+
+ORIGINAL CODE:
+{code[:1500]}
+
+ERROR:
+{result[:500]}
+
+USER'S ORIGINAL REQUEST: {user_request[:200]}
+
+Output ONLY the fixed code in a ```python block. No explanation."""
+                try:
+                    fixed, _ = call_llm_safe(
+                        [{"role": "user", "content": fix_prompt}],
+                        max_tokens=1500, temperature=0.3
+                    )
+                    fixed = unwrap_fiction_response(fixed)
+                    # Extract fixed code
+                    m = re.search(r"```(?:python)?\n(.*?)```", fixed, re.DOTALL)
+                    if m:
+                        fixed_code = m.group(1)
+                        # Verify the fix works
+                        verify_result = CodeSandbox.execute(fixed_code, reset=True)
+                        if "error" not in verify_result.lower() and "Traceback" not in verify_result:
+                            log(f"CodeVerifier: block {i+1} FIXED and verified")
+                            fixed_blocks.append(fixed_code)
+                            continue
+                except Exception:
+                    pass
+            else:
+                log(f"CodeVerifier: block {i+1} PASSED")
+                fixed_blocks.append(code)
+        
+        # Reconstruct response with verified code
+        if fixed_blocks and len(fixed_blocks) == len(executable_blocks):
+            # Replace code blocks in original response
+            verified_response = response
+            for original, fixed in zip(executable_blocks, fixed_blocks):
+                if original != fixed:
+                    verified_response = verified_response.replace(original, fixed, 1)
+            return verified_response + "\n\n✅ Code verified — runs without errors."
+        
+        return response
+
+
+class FactChecker:
+    """Fact-Checking — verifies factual claims via web search.
+    
+    After generating a response with factual claims, FactChecker:
+    1. Extracts verifiable claims (numbers, dates, names, events)
+    2. Web-searches each claim
+    3. If a claim is contradicted, flags it and provides the correct info
+    
+    Use for: news, history, science, statistics — anything factual.
+    """
+    
+    CLAIM_PATTERNS = [
+        # Numbers with context
+        r"(?:is|was|are|were)\s+(\d+[\d,]*\.?\d*)\s*(?:percent|million|billion|thousand|people|years|days|hours)",
+        # Dates
+        r"(?:in|on|since)\s+(\d{4})",
+        # "X is Y" statements
+        r"(\w[\w\s]+)\s+is\s+(?:the|a|an)\s+(\w[\w\s]+)",
+    ]
+    
+    @classmethod
+    def extract_claims(cls, text: str) -> List[str]:
+        """Extract verifiable claims from text."""
+        claims = []
+        for pattern in cls.CLAIM_PATTERNS:
+            matches = re.findall(pattern, text)
+            for m in matches:
+                if isinstance(m, tuple):
+                    claims.append(" ".join(m))
+                else:
+                    claims.append(m)
+        return claims[:3]  # max 3 claims to check (avoid rate limits)
+    
+    @classmethod
+    def check_facts(cls, response: str) -> str:
+        """Check factual claims in a response. Returns response with fact-check notes."""
+        claims = cls.extract_claims(response)
+        if not claims:
+            return response
+        
+        log(f"FactChecker: checking {len(claims)} claims...")
+        corrections = []
+        
+        for claim in claims:
+            try:
+                # Web search the claim
+                search_result = run_tool("web_search", {"query": claim})
+                # Ask LLM to verify
+                verify_prompt = f"""Is this claim TRUE or FALSE based on the search results?
+
+CLAIM: {claim}
+
+SEARCH RESULTS:
+{search_result[:500]}
+
+Output:
+VERDICT: TRUE or FALSE or UNCERTAIN
+CORRECTION: (if false, what's the truth?)
+Be brief."""
+                verdict, _ = call_llm_safe(
+                    [{"role": "user", "content": verify_prompt}],
+                    max_tokens=100, temperature=0.2
+                )
+                verdict = unwrap_fiction_response(verdict)
+                if "FALSE" in verdict.upper():
+                    # Extract correction
+                    corr_match = re.search(r"CORRECTION:\s*(.+)", verdict, re.DOTALL)
+                    if corr_match:
+                        corrections.append(f"⚠️ Claim '{claim}' may be incorrect. {corr_match.group(1).strip()}")
+            except Exception:
+                continue
+        
+        if corrections:
+            return response + "\n\n📋 Fact-check notes:\n" + "\n".join(corrections)
+        return response + "\n\n✅ Facts verified."
+
+
+class ProactiveIntelligence:
+    """Proactive Intelligence — anticipates user needs and suggests actions.
+    
+    After each conversation, analyzes:
+    - What topics the user is working on
+    - What they might need next
+    - What they've forgotten
+    
+    Example: If user asks about BTC price 3 times in a day, proactively
+    suggests setting up a price alert.
+    
+    Runs in background — doesn't slow down responses.
+    """
+    
+    _topic_history: List[Dict] = []
+    
+    @classmethod
+    def record_interaction(cls, user_message: str):
+        """Record what the user is asking about."""
+        # Extract topics (simple keyword extraction)
+        msg_lower = user_message.lower()
+        topics = []
+        topic_keywords = {
+            "trading": ["btc", "eth", "price", "buy", "sell", "trade", "crypto", "bitcoin"],
+            "coding": ["code", "python", "function", "debug", "error", "script"],
+            "research": ["search", "find", "research", "what is", "explain"],
+            "writing": ["write", "article", "essay", "story", "content"],
+            "system": ["status", "tools", "provider", "model"],
+        }
+        for topic, keywords in topic_keywords.items():
+            if any(kw in msg_lower for kw in keywords):
+                topics.append(topic)
+        
+        for topic in topics:
+            cls._topic_history.append({"topic": topic, "ts": time.time()})
+        
+        # Keep last 100
+        cls._topic_history = cls._topic_history[-100:]
+    
+    @classmethod
+    def get_suggestions(cls) -> Optional[str]:
+        """Generate proactive suggestions based on patterns. Returns None if no suggestion."""
+        if len(cls._topic_history) < 5:
+            return None
+        
+        # Count topics in last hour
+        now = time.time()
+        recent = [t for t in cls._topic_history if now - t["ts"] < 3600]
+        if len(recent) < 3:
+            return None
+        
+        from collections import Counter
+        topic_counts = Counter(t["topic"] for t in recent)
+        top_topic = topic_counts.most_common(1)[0]
+        
+        # If user asked about same topic 3+ times in last hour, suggest automation
+        if top_topic[1] >= 3:
+            suggestions = {
+                "trading": "💡 I noticed you're checking prices frequently. Want me to set up automatic price alerts? Say 'alert me when BTC drops below $60K'.",
+                "coding": "💡 You're doing a lot of coding. Want me to create a code project template? Say 'create a project structure for X'.",
+                "research": "💡 Lots of research today. Want me to compile a summary? Say 'summarize everything we discussed'.",
+                "writing": "💡 You're writing a lot. Want me to help with a longer piece? Say 'write a 2000-word article about X'.",
+            }
+            return suggestions.get(top_topic[0])
+        
+        return None
+
+
 def call_llm_safe(messages, max_tokens=1024, temperature=0.7):
     """BRILLIANT SMART ROUTER v2 — fully uncensored.
     
@@ -6972,6 +7379,14 @@ def agent_turn(user_message: str, chat_id: str = "default",
         # Add Knowledge Graph context (structured facts)
         if kg_context:
             system_prompt = system_prompt + "\n\n" + kg_context
+        
+        # Add Self-Improvement adjustments (learned from user feedback)
+        try:
+            si_adjustments = SelfImprovement.get_adjustments()
+            if si_adjustments:
+                system_prompt = system_prompt + "\n\n" + si_adjustments
+        except Exception:
+            pass
 
         # Build message history — INFINITE CONTEXT via rolling summary
         # (last 20 messages verbatim + summary of everything older)
@@ -7029,11 +7444,24 @@ def agent_turn(user_message: str, chat_id: str = "default",
         # ULTRA-GENIUS: Use full reasoning pipeline for hard questions
         use_deep_reasoning = ReasoningEngine.should_use_reasoning(user_message, messages)
         
+        # APEX-GENIUS: Use Multi-Agent Debate for decision/controversial questions
+        is_decision_question = any(kw in user_msg_lower for kw in [
+            "should i", "which is better", "vs", "versus", "or should",
+            "best option", "recommend", "pros and cons", "trade-off",
+            "worth it", "is it worth", "debate", "controversial",
+        ])
+        
         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_decision_question and iteration == 0:
+                # APEX-GENIUS: Multi-agent debate for decisions
+                log("ApexGenius: using MultiAgentDebate for decision question")
+                text, source = MultiAgentDebate.debate(
+                    messages, max_tokens=s.get("max_tokens", 4096)
+                )
             elif use_deep_reasoning and iteration == 0:
                 # ULTRA-GENIUS: Full reasoning pipeline (think → draft → critique → refine)
                 log("UltraGenius: using ReasoningEngine (o1-style thinking)")
@@ -7096,6 +7524,37 @@ def agent_turn(user_message: str, chat_id: str = "default",
             accumulated_text = text
             parsed = parse_tool_call(text)
             if parsed is None:
+                # POST-PROCESSING: Code verification, fact-checking, proactive intelligence
+                # Run in background for non-blocking improvements
+                try:
+                    # 1. CODE VERIFICATION — if response contains code, verify it runs
+                    if "```python" in text or "def " in text or "import " in text:
+                        log("PostProcess: verifying code...")
+                        text = CodeVerifier.verify_and_fix(text, user_message)
+                except Exception as e:
+                    log(f"CodeVerifier failed: {e}")
+                
+                # 2. PROACTIVE INTELLIGENCE — record topic for pattern analysis
+                try:
+                    ProactiveIntelligence.record_interaction(user_message)
+                except Exception:
+                    pass
+                
+                # 3. SELF-IMPROVEMENT — record feedback from previous turn
+                # (analyze if user's current message is positive/negative about last response)
+                try:
+                    history = conv.get_messages(limit=2)
+                    if len(history) >= 1:
+                        last_ai = history[-1] if history[-1]["role"] == "assistant" else ""
+                        if last_ai:
+                            SelfImprovement.record_feedback(
+                                history[-2]["content"] if len(history) >= 2 else "",
+                                last_ai["content"],
+                                user_message
+                            )
+                except Exception:
+                    pass
+                
                 # Final answer
                 yield text, image_path, source
                 conv.add("user", user_message)