Upload app/agents/prompt_agent.py with huggingface_hub

app/agents/prompt_agent.py

@@ -0,0 +1,494 @@
+"""
+Prompt Agent
+
+Auto-generates prompts based on:
+- Learning context
+- User behavior
+- Gesture triggers
+- RL feedback
+
+Features:
+- Smart prompt templates
+- Context-aware generation
+- Auto-submit capability
+- Multiple LLM routing
+"""
+
+import re
+from typing import Dict, List, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+import json
+
+
+@dataclass
+class PromptTemplate:
+    """A prompt template for specific use cases"""
+    name: str
+    template: str
+    variables: List[str]
+    llm_preferences: List[str] = field(default_factory=list)
+    priority: int = 1
+
+
+@dataclass
+class GeneratedPrompt:
+    """A generated prompt ready for submission"""
+    content: str
+    template_used: Optional[str]
+    context: Dict[str, Any]
+    llm_targets: List[str]
+    auto_submit: bool
+    generated_at: datetime = field(default_factory=datetime.now)
+
+
+@dataclass
+class PromptHistory:
+    """History of generated prompts"""
+    prompt: str
+    response: str
+    llm_used: str
+    feedback: Optional[int]
+    timestamp: datetime
+
+
+class PromptAgent:
+    """
+    Auto-generates prompts for LLM queries based on context.
+    
+    Features:
+    - Context-aware templates
+    - Gesture-triggered generation
+    - Smart routing to appropriate LLMs
+    - Auto-submit capability
+    
+    Inspired by GestureGPT triple-agent system:
+    - Gesture Description Agent → identifies intent
+    - Context Management Agent → maintains context
+    - Gesture Inference Agent → generates prompts
+    """
+    
+    def __init__(self):
+        self.templates = self._initialize_templates()
+        self.history: List[PromptHistory] = []
+        self.context_buffer: List[Dict] = []
+        self.max_context_size = 20
+        
+        self.gesture_intent_mappings = {
+            "2_finger_swipe_right": "query_multi_llm",
+            "2_finger_swipe_left": "query_specific",
+            "1_finger_tap": "trigger_rl",
+            "pinch": "capture_and_query",
+            "open_palm": "pause_or_stop"
+        }
+    
+    def _initialize_templates(self) -> Dict[str, PromptTemplate]:
+        """Initialize prompt templates for different scenarios"""
+        return {
+            "learning_explain": PromptTemplate(
+                name="Learning Explanation",
+                template="""I am learning about {topic}. Please explain the key concepts in a clear, structured way.
+
+Context from my learning session:
+- Current progress: {progress}%
+- I was confused about: {confusion_point}
+- My learning goal is: {learning_goal}
+
+Please provide:
+1. A brief overview
+2. Key concepts to understand
+3. Common misconceptions to avoid
+4. A simple example I can relate to""",
+                variables=["topic", "progress", "confusion_point", "learning_goal"],
+                llm_preferences=["chatgpt", "gemini"],
+                priority=3
+            ),
+            
+            "doubt_resolution": PromptTemplate(
+                name="Doubt Resolution",
+                template="""I'm struggling with this concept: {concept}
+
+I've tried understanding it this way: {attempted_approach}
+
+What specifically confuses me is: {confusion}
+
+Please help me understand:
+1. The simplest explanation
+2. A step-by-step breakdown
+3. An analogy or real-world example""",
+                variables=["concept", "attempted_approach", "confusion"],
+                llm_preferences=["chatgpt"],
+                priority=5
+            ),
+            
+            "summarize_content": PromptTemplate(
+                name="Content Summarization",
+                template="""Please summarize this content in a way that helps me learn:
+
+{content}
+
+Include:
+1. Main takeaways (3-5 bullet points)
+2. Key definitions
+3. How this relates to {topic}""",
+                variables=["content", "topic"],
+                llm_preferences=["gemini", "chatgpt"],
+                priority=2
+            ),
+            
+            "practice_questions": PromptTemplate(
+                name="Practice Questions",
+                template="""Generate 5 practice questions to test my understanding of {topic}.
+
+Difficulty level: {difficulty}
+
+Include:
+- 2 factual recall questions
+- 2 application questions
+- 1 analysis/evaluation question""",
+                variables=["topic", "difficulty"],
+                llm_preferences=["chatgpt"],
+                priority=2
+            ),
+            
+            "compare_concepts": PromptTemplate(
+                name="Concept Comparison",
+                template="""Compare and contrast these concepts for my learning:
+
+Concept A: {concept_a}
+Concept B: {concept_b}
+
+Please structure your response as:
+1. Similarities
+2. Differences
+3. When to use each
+4. Common confusion points""",
+                variables=["concept_a", "concept_b"],
+                llm_preferences=["chatgpt", "gemini"],
+                priority=3
+            ),
+            
+            "spaced_repetition": PromptTemplate(
+                name="Spaced Repetition Review",
+                template="""Help me review what I learned about {topic}.
+
+Based on spaced repetition principles, create:
+1. A quick 3-question review
+2. Key points to remember
+3. What to focus on next
+
+Previous understanding level: {mastery_level}/5""",
+                variables=["topic", "mastery_level"],
+                llm_preferences=["chatgpt"],
+                priority=2
+            ),
+            
+            "gesture_query": PromptTemplate(
+                name="Gesture-Triggered Query",
+                template="""Based on my current learning context:
+- Topic: {topic}
+- Confusion level: {confusion_level}%
+- Recent question: {recent_question}
+
+And my gesture action: {gesture_action}
+
+Please provide a helpful response.""",
+                variables=["topic", "confusion_level", "recent_question", "gesture_action"],
+                llm_preferences=["chatgpt", "gemini"],
+                priority=4
+            ),
+            
+            "rl_optimization": PromptTemplate(
+                name="RL-Optimized Response",
+                template="""Learning context:
+{context}
+
+Previous interaction quality: {quality}/5
+
+Based on my feedback and learning patterns, please:
+1. Adjust explanation complexity
+2. Focus on my weak areas
+3. Provide practice opportunities""",
+                variables=["context", "quality"],
+                llm_preferences=["chatgpt"],
+                priority=3
+            )
+        }
+    
+    def generate_prompt(
+        self,
+        template_name: str,
+        context: Dict[str, Any],
+        auto_submit: bool = True
+    ) -> GeneratedPrompt:
+        """Generate a prompt from template and context"""
+        
+        if template_name not in self.templates:
+            template_name = "learning_explain"
+        
+        template = self.templates[template_name]
+        
+        try:
+            content = template.template.format(**context)
+        except KeyError as e:
+            content = template.template
+            for key in context:
+                content = content.replace(f"{{{key}}}", str(context[key]))
+        
+        prompt = GeneratedPrompt(
+            content=content,
+            template_used=template_name,
+            context=context,
+            llm_targets=template.llm_preferences,
+            auto_submit=auto_submit
+        )
+        
+        return prompt
+    
+    def generate_from_gesture(
+        self,
+        gesture: str,
+        learning_context: Dict[str, Any]
+    ) -> GeneratedPrompt:
+        """Generate prompt based on gesture action"""
+        
+        intent = self.gesture_intent_mappings.get(gesture, "query_multi_llm")
+        
+        context = {
+            "topic": learning_context.get("topic", "this topic"),
+            "progress": learning_context.get("progress", 50),
+            "confusion_point": learning_context.get("confusion_point", ""),
+            "learning_goal": learning_context.get("learning_goal", "understand the basics"),
+            "confusion_level": learning_context.get("confusion_level", 30),
+            "recent_question": learning_context.get("recent_question", ""),
+            "gesture_action": gesture,
+            "content": learning_context.get("content", ""),
+            "difficulty": learning_context.get("difficulty", "intermediate"),
+            "concept": learning_context.get("concept", ""),
+            "attempted_approach": learning_context.get("attempted_approach", ""),
+            "concept_a": learning_context.get("concept_a", ""),
+            "concept_b": learning_context.get("concept_b", "")
+        }
+        
+        if intent == "query_multi_llm":
+            template_name = "gesture_query"
+        elif intent == "trigger_rl":
+            template_name = "rl_optimization"
+        elif intent == "capture_and_query":
+            template_name = "summarize_content"
+        else:
+            template_name = "learning_explain"
+        
+        return self.generate_prompt(template_name, context, auto_submit=True)
+    
+    def generate_doubt_prompt(
+        self,
+        doubt_text: str,
+        context: Dict[str, Any]
+    ) -> GeneratedPrompt:
+        """Generate prompt for doubt resolution"""
+        
+        context.update({
+            "concept": doubt_text,
+            "attempted_approach": context.get("attempted_approach", "I've read the material but don't understand"),
+            "confusion": context.get("confusion", "the underlying concept")
+        })
+        
+        return self.generate_prompt("doubt_resolution", context)
+    
+    def update_context(self, new_context: Dict):
+        """Update the context buffer"""
+        self.context_buffer.append({
+            **new_context,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        if len(self.context_buffer) > self.max_context_size:
+            self.context_buffer.pop(0)
+    
+    def get_current_context(self) -> Dict:
+        """Get the most recent context"""
+        if not self.context_buffer:
+            return {}
+        return self.context_buffer[-1]
+    
+    def record_response(
+        self, 
+        prompt: str, 
+        response: str, 
+        llm: str,
+        feedback: Optional[int] = None
+    ):
+        """Record a prompt-response pair for learning"""
+        history_entry = PromptHistory(
+            prompt=prompt,
+            response=response,
+            llm_used=llm,
+            feedback=feedback,
+            timestamp=datetime.now()
+        )
+        
+        self.history.append(history_entry)
+        
+        if len(self.history) > 100:
+            self.history = self.history[-50:]
+    
+    def get_best_template_for_context(self, context: Dict) -> str:
+        """Determine the best template for current context"""
+        
+        if context.get("action") == "doubt":
+            return "doubt_resolution"
+        
+        if context.get("action") == "review":
+            return "spaced_repetition"
+        
+        if context.get("action") == "compare":
+            return "compare_concepts"
+        
+        if context.get("action") == "practice":
+            return "practice_questions"
+        
+        if context.get("action") == "summarize":
+            return "summarize_content"
+        
+        return "learning_explain"
+    
+    def get_suggested_prompts(self, context: Dict) -> List[GeneratedPrompt]:
+        """Get suggested prompts based on context"""
+        suggestions = []
+        
+        if context.get("confusion_level", 0) > 50:
+            suggestions.append(self.generate_prompt(
+                "doubt_resolution",
+                context,
+                auto_submit=False
+            ))
+        
+        if context.get("topic"):
+            suggestions.append(self.generate_prompt(
+                "learning_explain",
+                context,
+                auto_submit=False
+            ))
+        
+        if context.get("needs_review"):
+            suggestions.append(self.generate_prompt(
+                "spaced_repetition",
+                context,
+                auto_submit=False
+            ))
+        
+        return suggestions[:3]
+    
+    def analyze_and_suggest(self, user_input: str, context: Dict) -> Dict:
+        """Analyze user input and suggest appropriate action"""
+        
+        user_lower = user_input.lower()
+        
+        suggestions = {
+            "action": "explain",
+            "template": "learning_explain",
+            "confidence": 0.5
+        }
+        
+        if any(word in user_lower for word in ["what", "how", "why", "explain"]):
+            suggestions["action"] = "explain"
+            suggestions["template"] = "learning_explain"
+            suggestions["confidence"] = 0.8
+        
+        elif any(word in user_lower for word in ["compare", "difference", "versus", "vs"]):
+            suggestions["action"] = "compare"
+            suggestions["template"] = "compare_concepts"
+            suggestions["confidence"] = 0.9
+        
+        elif any(word in user_lower for word in ["confused", "don't understand", "stuck", "help"]):
+            suggestions["action"] = "doubt"
+            suggestions["template"] = "doubt_resolution"
+            suggestions["confidence"] = 0.85
+        
+        elif any(word in user_lower for word in ["practice", "quiz", "test", "question"]):
+            suggestions["action"] = "practice"
+            suggestions["template"] = "practice_questions"
+            suggestions["confidence"] = 0.85
+        
+        elif any(word in user_lower for word in ["summary", "summarize", "overview"]):
+            suggestions["action"] = "summarize"
+            suggestions["template"] = "summarize_content"
+            suggestions["confidence"] = 0.9
+        
+        return suggestions
+
+
+class AutoSubmitAgent:
+    """
+    Auto-submits prompts to LLMs and manages the submission flow.
+    
+    Features:
+    - Automatic prompt submission
+    - Tab/input field simulation
+    - Rate limit awareness
+    - Multi-LLM coordination
+    """
+    
+    def __init__(self, prompt_agent: PromptAgent):
+        self.prompt_agent = prompt_agent
+        self.pending_submissions: List[Dict] = []
+        self.submission_results: List[Dict] = []
+        
+        self.auto_submit_enabled = True
+        self.submit_delay = 0.5
+    
+    def prepare_submission(
+        self, 
+        prompt: GeneratedPrompt,
+        target_elements: Optional[Dict] = None
+    ) -> Dict:
+        """Prepare a prompt for submission"""
+        
+        submission = {
+            "prompt": prompt,
+            "target_elements": target_elements or {
+                "input_selector": "textarea[placeholder*='message'], textarea[placeholder*='Ask'], input[type='text']",
+                "submit_selector": "button[type='submit'], button:contains('Send'), button:contains('Submit')"
+            },
+            "status": "ready",
+            "created_at": datetime.now().isoformat()
+        }
+        
+        self.pending_submissions.append(submission)
+        return submission
+    
+    def execute_submission(
+        self, 
+        submission: Dict,
+        browser_controller=None
+    ) -> Dict:
+        """Execute the submission (simulated)"""
+        
+        result = {
+            "status": "submitted",
+            "timestamp": datetime.now().isoformat(),
+            "prompt_content": submission["prompt"].content,
+            "target_url": "simulated"
+        }
+        
+        self.submission_results.append(result)
+        self.pending_submissions.remove(submission)
+        
+        return result
+    
+    def get_submission_status(self) -> Dict:
+        """Get current submission status"""
+        return {
+            "pending": len(self.pending_submissions),
+            "completed": len(self.submission_results),
+            "auto_submit_enabled": self.auto_submit_enabled
+        }
+    
+    def cancel_pending(self):
+        """Cancel all pending submissions"""
+        self.pending_submissions = []
+    
+    def get_recent_results(self, limit: int = 10) -> List[Dict]:
+        """Get recent submission results"""
+        return self.submission_results[-limit:]