Disfluency Calibration Failures

class DisfluencyCalibrator:
    """Calibrate disfluency to persona and context"""
    
    PERSONA_PROFILES = {
        "casual_sales": {
            "fillers": ["um", "like", "so", "you know", "right"],
            "frequency": "high",  # 2-3 per response
            "style": "natural_casual"
        },
        "professional_service": {
            "fillers": ["let me see", "one moment", "let me check"],
            "frequency": "low",  # 0-1 per response
            "style": "thinking_professional"
        },
        "medical_clinical": {
            "fillers": ["let me confirm", "one moment"],
            "frequency": "minimal",  # Only when needed
            "style": "dignified"
        },
        "financial_banking": {
            "fillers": ["let me verify", "one moment"],
            "frequency": "minimal",
            "style": "authoritative"
        },
        "friendly_college": {
            "fillers": ["so", "yeah", "cool", "right"],
            "frequency": "moderate",
            "style": "youthful_casual"
        }
    }
    
    CONTEXT_OVERRIDES = {
        "fraud_alert": {"frequency": "minimal", "style": "authoritative"},
        "medical_serious": {"frequency": "minimal", "style": "dignified"},
        "legal_matter": {"frequency": "none", "style": "precise"},
        "appointment_reminder": {"frequency": "low", "style": "clear"},
        "casual_inquiry": {"frequency": "normal", "style": "persona_default"}
    }
    
    def __init__(self, base_persona: str):
        self.persona = self.PERSONA_PROFILES.get(
            base_persona, 
            self.PERSONA_PROFILES["professional_service"]
        )
        self.caller_energy = "normal"
    
    def detect_caller_energy(self, caller_transcript: str, 
                             speech_rate: float) -> str:
        """Detect caller energy level"""
        rushed_signals = [
            "quickly", "hurry", "brief", "just tell me",
            "short on time", "in a rush"
        ]
        
        relaxed_signals = [
            "no rush", "take your time", "curious",
            "tell me more", "interesting"
        ]
        
        text_lower = caller_transcript.lower()
        
        # Check speech rate (words per minute)
        if speech_rate > 180:  # Fast speaker
            return "rushed"
        elif speech_rate < 120:  # Slow speaker
            return "relaxed"
        
        # Check verbal signals
        if any(signal in text_lower for signal in rushed_signals):
            return "rushed"
        if any(signal in text_lower for signal in relaxed_signals):
            return "relaxed"
        
        return "normal"
    
    def get_disfluency_config(self, context: str = None) -> dict:
        """Get disfluency config for current context"""
        config = self.persona.copy()
        
        # Apply context overrides
        if context and context in self.CONTEXT_OVERRIDES:
            override = self.CONTEXT_OVERRIDES[context]
            config.update(override)
        
        # Adapt to caller energy
        if self.caller_energy == "rushed":
            # Reduce fillers for time-pressed callers
            if config["frequency"] == "high":
                config["frequency"] = "moderate"
            elif config["frequency"] == "moderate":
                config["frequency"] = "low"
            elif config["frequency"] == "low":
                config["frequency"] = "minimal"
        
        return config
    
    def inject_disfluency(self, response: str, config: dict) -> str:
        """Inject appropriate disfluency into response"""
        if config["frequency"] == "none":
            return response
        
        fillers = config["fillers"]
        frequency = config["frequency"]
        
        # Determine number of fillers
        filler_count = {
            "minimal": random.choice([0, 0, 1]),
            "low": random.choice([0, 1, 1]),
            "moderate": random.choice([1, 1, 2]),
            "high": random.choice([1, 2, 3])
        }.get(frequency, 0)
        
        if filler_count == 0:
            return response
        
        # Natural insertion points
        sentences = response.split(". ")
        
        for _ in range(min(filler_count, len(sentences))):
            idx = random.randint(0, len(sentences) - 1)
            filler = random.choice(fillers)
            
            # Vary insertion position
            position = random.choice(["start", "mid"])
            
            if position == "start" and not sentences[idx].startswith(filler):
                sentences[idx] = f"{filler.capitalize()}, {sentences[idx].lower()}"
            elif position == "mid":
                words = sentences[idx].split()
                if len(words) > 3:
                    insert_pos = random.randint(2, len(words) - 1)
                    words.insert(insert_pos, f", {filler},")
                    sentences[idx] = " ".join(words)
        
        return ". ".join(sentences)


class DisfluencyValidator:
    """Validate disfluency appropriateness"""
    
    INAPPROPRIATE_COMBINATIONS = {
        "medical": ["um", "like", "you know", "haha", "lol"],
        "legal": ["um", "like", "you know", "basically", "stuff"],
        "financial": ["like", "you know", "stuff", "thing"],
        "fraud": ["um", "like", "you know", "maybe", "I think"]
    }
    
    def validate(self, response: str, context: str) -> dict:
        """Validate response disfluency for context"""
        inappropriate = self.INAPPROPRIATE_COMBINATIONS.get(context, [])
        
        found = []
        for filler in inappropriate:
            if filler.lower() in response.lower():
                found.append(filler)
        
        return {
            "appropriate": len(found) == 0,
            "inappropriate_fillers": found,
            "context": context,
            "recommendation": self.get_recommendation(found, context)
        }
    
    def get_recommendation(self, found: list, context: str) -> str:
        if not found:
            return "Disfluency appropriate for context"
        
        return (f"Remove casual fillers ({', '.join(found)}) for "
                f"{context} context. Use 'let me confirm' or "
                f"'one moment' instead.")

instructions: |
  ## DISFLUENCY CALIBRATION
  
  Your speaking style must match your PERSONA and CONTEXT:
  
  PERSONA: [Friendly college outreach rep]
  Default style: Natural, youthful, some fillers okay
  Fillers allowed: "so", "yeah", "right", "cool"
  Fillers to avoid: Medical/legal precision language
  
  CONTEXT OVERRIDES:
  - If discussing sensitive topics → reduce casual fillers
  - If caller seems rushed → be more direct, fewer fillers
  - If caller is relaxed → match their energy
  
  CALLER ADAPTATION:
  - Rushed caller: "Sure! Here are the main points..."
  - Relaxed caller: "So yeah, basically the role is..."
  
  NEVER:
  - Sound robotic (some natural hesitation is good)
  - Use heavy fillers in serious contexts
  - Keep same energy regardless of caller
  - Force fillers into every sentence
  
  NATURAL VARIATION:
  - Don't put fillers in predictable positions
  - Vary which fillers you use
  - Match filler density to conversation energy