Language Barrier Failures

class LanguageBarrierHandler:
    """Handle language barrier situations"""
    
    SUPPORTED_LANGUAGES = ["english", "hindi", "hinglish"]
    
    UNSUPPORTED_INDICATORS = [
        "low_asr_confidence",  # < 0.3 average
        "high_unknown_ratio",  # > 50% unknown words
        "repeated_failures",   # 3+ "didn't understand"
        "no_response_fit"      # Response doesn't match any expected
    ]
    
    NEGOTIATION_PHRASES = {
        "english": "I'm sorry, I can only speak English or Hindi. "
                  "Can you switch to one of those?",
        "hindi": "Sorry, mujhe sirf English ya Hindi aati hai. "
                "Kya aap English ya Hindi mein baat kar sakte hain?",
    }
    
    HANDOFF_PHRASES = {
        "english": "I'm having trouble understanding. Let me connect "
                  "you with someone who can help better.",
        "hindi": "Mujhe samajh nahi aa raha. Main aapko kisi aur se "
                "connect karta hoon."
    }
    
    def __init__(self):
        self.failure_count = 0
        self.detected_language = None
    
    def detect_language(self, audio_segment) -> dict:
        """Detect language from audio before ASR"""
        # Use language ID model
        language_probs = self.language_id_model.predict(audio_segment)
        
        top_language = max(language_probs, key=language_probs.get)
        confidence = language_probs[top_language]
        
        return {
            "detected": top_language,
            "confidence": confidence,
            "supported": top_language in self.SUPPORTED_LANGUAGES,
            "all_probs": language_probs
        }
    
    def check_comprehension(self, asr_result: dict) -> dict:
        """Check if we understood the input"""
        confidence = asr_result.get("confidence", 0)
        transcript = asr_result.get("transcript", "")
        
        # Check for indicators of barrier
        issues = []
        
        if confidence < 0.3:
            issues.append("low_confidence")
        
        if len(transcript.split()) < 2 and confidence < 0.5:
            issues.append("near_empty")
        
        if self.contains_garbage(transcript):
            issues.append("garbage_text")
        
        if issues:
            self.failure_count += 1
        else:
            self.failure_count = 0
        
        return {
            "understood": len(issues) == 0,
            "issues": issues,
            "failure_count": self.failure_count,
            "needs_action": self.failure_count >= 2
        }
    
    def get_action(self, comprehension: dict, 
                   language_detection: dict) -> dict:
        """Determine appropriate action for barrier"""
        if not language_detection["supported"]:
            return {
                "action": "language_negotiation",
                "phrase": self.NEGOTIATION_PHRASES["english"],
                "fallback": "handoff"
            }
        
        if comprehension["failure_count"] >= 3:
            return {
                "action": "handoff",
                "phrase": self.HANDOFF_PHRASES["english"],
                "reason": "repeated_comprehension_failure"
            }
        
        if comprehension["failure_count"] >= 2:
            return {
                "action": "negotiate",
                "phrase": self.NEGOTIATION_PHRASES["english"]
            }
        
        return {"action": "continue"}
    
    def handle_barrier(self, detection: dict, 
                        comprehension: dict) -> str:
        """Handle language barrier situation"""
        action = self.get_action(comprehension, detection)
        
        if action["action"] == "handoff":
            # Trigger human handoff
            self.trigger_handoff(
                reason="language_barrier",
                detected_language=detection.get("detected")
            )
            return action["phrase"]
        
        if action["action"] in ["negotiate", "language_negotiation"]:
            return action["phrase"]
        
        return None  # Continue normally


class LanguageNegotiator:
    """Negotiate language with caller"""
    
    def __init__(self, supported=["english", "hindi"]):
        self.supported = supported
        self.negotiation_attempts = 0
        self.max_attempts = 2
    
    def negotiate(self, current_language: str) -> dict:
        """Attempt to negotiate language switch"""
        self.negotiation_attempts += 1
        
        if self.negotiation_attempts > self.max_attempts:
            return {
                "success": False,
                "action": "handoff",
                "message": "I'm sorry, let me connect you with "
                          "someone who speaks your language."
            }
        
        return {
            "success": "pending",
            "message": "I can speak English or Hindi. "
                      "Can you use one of those?",
            "listen_for": self.supported
        }

instructions: |
  ## LANGUAGE BARRIER HANDLING
  
  Supported languages: English, Hindi, Hinglish
  
  If you CAN'T UNDERSTAND the caller:
  
  1. FIRST attempt: Ask to switch language
     "Sorry, I can only speak English or Hindi. 
      Can you use one of those?"
  
  2. SECOND attempt: Repeat ask, speak slower
     "I'm still having trouble. English ya Hindi—
      which do you prefer?"
  
  3. THIRD failure: Offer handoff
     "I'm having trouble understanding. Let me connect 
      you with someone who can help."
  
  SIGNS of language barrier:
  - Your response doesn't make sense to them
  - They keep speaking in unknown language
  - You can't parse what they're saying
  - 2+ "I didn't understand" in a row
  
  DO NOT:
  - Loop endlessly asking to repeat
  - Pretend to understand when you don't
  - Generate random responses to garbage input
  - Get frustrated or apologize repeatedly
  
  OUTCOME for unsupported language:
  - "unable_to_continue" with reason "language_barrier"
  - Or "handoff_requested" if transferring