Backchannel Timing Errors

class BackchannelManager:
    """Manage appropriate backchannel timing"""
    
    BACKCHANNELS = {
        "neutral_acknowledgment": ["right", "I see", "got it", "okay"],
        "empathetic": ["oh no", "I understand", "I'm sorry to hear that"],
        "encouraging": ["yes", "absolutely", "of course"],
        "thinking": ["let me see", "hmm"]
    }
    
    SILENCE_THRESHOLDS = {
        "micro_pause": 0.3,      # Normal speech pause
        "phrase_boundary": 0.8,   # Potential backchannel point
        "extended_pause": 2.0,    # Caller may be thinking
        "check_in_needed": 8.0    # Should acknowledge
    }
    
    def __init__(self):
        self.last_backchannel = 0
        self.caller_speaking_duration = 0
        self.mode = "normal"  # or "data_collection"
    
    def should_backchannel(self, audio_analysis: dict) -> dict:
        """Determine if backchannel is appropriate"""
        
        # Never backchannel during data collection
        if self.mode == "data_collection":
            return {"should": False, "reason": "data_collection_mode"}
        
        silence_duration = audio_analysis.get("silence_duration", 0)
        is_phrase_boundary = audio_analysis.get("phrase_boundary", False)
        caller_speaking_time = audio_analysis.get("speaking_duration", 0)
        pitch_pattern = audio_analysis.get("pitch_pattern", "neutral")
        
        # Don't backchannel on micro-pauses
        if silence_duration < self.SILENCE_THRESHOLDS["phrase_boundary"]:
            return {"should": False, "reason": "too_short"}
        
        # Check-in after long monologue without backchannel
        if (caller_speaking_time > self.SILENCE_THRESHOLDS["check_in_needed"] 
            and silence_duration > 0.5):
            return {
                "should": True,
                "type": "neutral_acknowledgment",
                "cue": "I see",
                "reason": "long_monologue_check_in"
            }
        
        # Natural phrase boundary
        if is_phrase_boundary and silence_duration > 0.8:
            cue_type = self.select_cue_type(audio_analysis)
            return {
                "should": True,
                "type": cue_type,
                "cue": self.select_cue(cue_type),
                "reason": "phrase_boundary"
            }
        
        return {"should": False, "reason": "no_trigger"}
    
    def select_cue_type(self, audio_analysis: dict) -> str:
        """Select appropriate cue type based on context"""
        sentiment = audio_analysis.get("sentiment", "neutral")
        
        if sentiment in ["frustrated", "sad", "upset"]:
            return "empathetic"
        elif sentiment in ["excited", "happy"]:
            return "encouraging"
        else:
            return "neutral_acknowledgment"
    
    def select_cue(self, cue_type: str) -> str:
        """Select specific cue from type"""
        cues = self.BACKCHANNELS.get(cue_type, ["okay"])
        return random.choice(cues)
    
    def enter_data_collection_mode(self):
        """Enter mode where backchannels are suppressed"""
        self.mode = "data_collection"
    
    def exit_data_collection_mode(self):
        """Exit data collection mode"""
        self.mode = "normal"


class PhraseBoundaryDetector:
    """Detect natural phrase boundaries in speech"""
    
    BOUNDARY_SIGNALS = {
        "pitch_drop": 0.7,       # Falling intonation
        "lengthened_vowel": 0.6, # Drawn out final word
        "filled_pause": 0.8,     # "um", "uh" indicates thinking
        "conjunction": 0.5      # "and", "but", "so" mid-thought
    }
    
    def detect_boundary(self, audio_features: dict, 
                        transcript: str) -> dict:
        """Detect if current pause is a phrase boundary"""
        
        signals = []
        confidence = 0
        
        # Check pitch pattern
        if audio_features.get("final_pitch_drop", False):
            signals.append("pitch_drop")
            confidence += self.BOUNDARY_SIGNALS["pitch_drop"]
        
        # Check for lengthened final syllable
        if audio_features.get("final_syllable_lengthened", False):
            signals.append("lengthened_vowel")
            confidence += self.BOUNDARY_SIGNALS["lengthened_vowel"]
        
        # Check if ends with conjunction (mid-thought)
        mid_thought_words = ["and", "but", "so", "because", "then"]
        last_word = transcript.strip().split()[-1].lower() if transcript else ""
        if last_word in mid_thought_words:
            # NOT a boundary - caller is mid-thought
            return {
                "is_boundary": False,
                "reason": "mid_thought_conjunction",
                "confidence": 0.1
            }
        
        return {
            "is_boundary": confidence > 0.5,
            "confidence": min(confidence, 1.0),
            "signals": signals
        }


class EmotionalBackchannelSelector:
    """Select emotionally appropriate backchannels"""
    
    EMOTION_CUES = {
        "frustrated": {
            "cues": ["I understand", "I'm sorry to hear that", 
                     "That sounds frustrating"],
            "avoid": ["uh-huh", "okay", "right"]
        },
        "happy": {
            "cues": ["That's great!", "Wonderful", "Excellent"],
            "avoid": ["I see", "okay"]
        },
        "sad": {
            "cues": ["I'm sorry", "I understand", "That must be difficult"],
            "avoid": ["uh-huh", "right", "okay"]
        },
        "neutral": {
            "cues": ["I see", "got it", "okay", "right"],
            "avoid": []
        }
    }
    
    def select(self, emotion: str) -> str:
        """Select appropriate backchannel for emotion"""
        config = self.EMOTION_CUES.get(emotion, self.EMOTION_CUES["neutral"])
        return random.choice(config["cues"])
    
    def validate(self, cue: str, emotion: str) -> bool:
        """Validate cue is appropriate for emotion"""
        config = self.EMOTION_CUES.get(emotion, {"avoid": []})
        return cue.lower() not in [c.lower() for c in config.get("avoid", [])]

instructions: |
  ## BACKCHANNEL TIMING
  
  Backchannels ("right", "I see", "got it") show active listening.
  But TIMING is critical.
  
  WHEN TO BACKCHANNEL:
  - After caller finishes a complete thought (natural pause)
  - During long monologues (every 8-10 seconds)
  - After emotional statements (use empathetic cue)
  
  WHEN TO STAY SILENT:
  - Caller is mid-sentence
  - Caller is reciting numbers/data
  - You just asked a question (wait for full answer)
  - Caller said "and", "but", "so" then paused (they're thinking)
  
  CUE MATCHING:
  - Frustration → "I understand" / "I'm sorry to hear that"
  - Happiness → "That's great!" / "Wonderful"
  - Neutral info → "I see" / "Got it"
  
  NEVER:
  - Say "uh-huh" to someone expressing frustration
  - Backchannel while they're giving you numbers
  - Interrupt mid-sentence with "right"
  - Stay completely silent during 15+ second monologue