Emotional Expression Overuse

class EmotionalExpressionManager:
    """Manage emotional expressions in responses"""
    
    EXPRESSIONS = {
        "laughter": ["haha", "ha", "hehe", "lol"],
        "positive_exclaim": ["amazing", "great", "perfect", "wonderful", "awesome"],
        "elongation": ["niiice", "ohhh", "yeaah", "riiight"],
        "empathy": ["oh no", "ugh", "that's rough", "ouch"]
    }
    
    FREQUENCY_LIMITS = {
        "laughter": 5,      # Max 1 in 5 turns
        "positive_exclaim": 4,
        "elongation": 5,
        "empathy": 3        # Can use more often when appropriate
    }
    
    def __init__(self):
        self.turn_count = 0
        self.last_expression_turn = {
            "laughter": -10,
            "positive_exclaim": -10,
            "elongation": -10,
            "empathy": -10
        }
    
    def can_use_expression(self, expression_type: str) -> bool:
        """Check if expression can be used"""
        limit = self.FREQUENCY_LIMITS.get(expression_type, 4)
        turns_since_last = self.turn_count - self.last_expression_turn[expression_type]
        return turns_since_last >= limit
    
    def use_expression(self, expression_type: str):
        """Record expression usage"""
        self.last_expression_turn[expression_type] = self.turn_count
    
    def increment_turn(self):
        """Increment turn counter"""
        self.turn_count += 1
    
    def validate_response(self, response: str, 
                          context: dict) -> dict:
        """Validate emotional expressions in response"""
        issues = []
        
        response_lower = response.lower()
        
        # Check for each expression type
        for exp_type, expressions in self.EXPRESSIONS.items():
            for exp in expressions:
                if exp in response_lower:
                    # Check frequency
                    if not self.can_use_expression(exp_type):
                        issues.append({
                            "type": "frequency_violation",
                            "expression": exp,
                            "message": f"'{exp}' used too recently"
                        })
                    
                    # Check context appropriateness
                    if exp_type == "laughter":
                        if not self.context_warrants_laughter(context):
                            issues.append({
                                "type": "context_mismatch",
                                "expression": exp,
                                "message": "Laughter without comedic trigger"
                            })
                    
                    if exp_type == "positive_exclaim":
                        if context.get("sentiment") == "negative":
                            issues.append({
                                "type": "context_mismatch",
                                "expression": exp,
                                "message": "Positive exclaim in negative context"
                            })
        
        # Check exclamation frequency
        exclaim_count = response.count('!')
        if exclaim_count > 1:
            issues.append({
                "type": "exclamation_overuse",
                "count": exclaim_count,
                "message": "Too many exclamation marks"
            })
        
        return {
            "valid": len(issues) == 0,
            "issues": issues
        }
    
    def context_warrants_laughter(self, context: dict) -> bool:
        """Check if context has comedic element"""
        humor_signals = [
            "joke", "funny", "haha", "lol", "kidding",
            "hilarious", "laughing", "cracked up"
        ]
        
        last_caller_msg = context.get("last_caller_message", "").lower()
        return any(signal in last_caller_msg for signal in humor_signals)
    
    def suggest_alternative(self, expression: str, 
                           context: dict) -> str:
        """Suggest alternative to overused expression"""
        alternatives = {
            "haha": ["nice", "oh", "yeah", "right"],
            "amazing": ["got it", "cool", "nice", "sounds good"],
            "great": ["perfect", "works for me", "okay"],
            "!": [".", "—"]
        }
        
        return random.choice(alternatives.get(expression, [""]))


class ContextualEmotionSelector:
    """Select appropriate emotion for context"""
    
    def select_emotion(self, context: dict) -> dict:
        """Select appropriate emotional expression"""
        sentiment = context.get("sentiment", "neutral")
        caller_emotion = context.get("caller_emotion", "neutral")
        content_type = context.get("content_type", "informational")
        
        if sentiment == "negative" or caller_emotion in ["frustrated", "sad"]:
            return {
                "expression_type": "empathy",
                "options": ["I understand", "That's frustrating", 
                           "I'm sorry to hear that"]
            }
        
        if content_type == "joke" or context.get("humor_detected"):
            return {
                "expression_type": "laughter",
                "options": ["Ha", "Haha", "That's funny"]
            }
        
        if content_type == "achievement":
            return {
                "expression_type": "positive_exclaim",
                "options": ["Nice!", "That's great!", "Congrats!"]
            }
        
        # Default to neutral acknowledgment
        return {
            "expression_type": "neutral",
            "options": ["Got it", "Okay", "Sure", "I see"]
        }

instructions: |
  ## EMOTIONAL EXPRESSION CONTROL
  
  Emotional expressions are powerful because they're RARE.
  
  LAUGHTER RULES:
  - Laugh at most once every 4-5 turns
  - Never open two consecutive turns with "haha"
  - Only laugh when there's a real comedic beat
  - If no clear joke, use "oh" or "yeah" instead
  
  POSITIVE EXPRESSIONS:
  - "Amazing" / "Great" / "Perfect": Max once per conversation
  - Reserve for actual achievements, not mundane info
  - "My name is John" → "Got it, John" (NOT "Amazing!")
  
  EXCLAMATION MARKS:
  - Maximum one per response
  - Most sentences should end with periods
  - Constant enthusiasm is exhausting
  
  ELONGATION ("niiice"):
  - Max once every 5+ turns
  - Only for genuinely exciting moments
  
  EMPATHY:
  - Use when context is genuinely negative
  - "That's rough" / "I'm sorry" / "Ugh, that's frustrating"
  - Don't laugh at someone's problems
  
  CONTEXT MATCHING:
  - Serious context (emergency, complaint) → No laughter
  - Mundane info (name, address) → Neutral acknowledgment
  - Genuine humor → One laugh okay
  - Good news → Enthusiasm appropriate
  
  SELF-CHECK:
  If your last turn started with "haha", this turn should not.
  If the caller shared bad news, do not express positive excitement.