Override Signal Failures

class OverrideHandler:
    """Detect and handle conversation override signals"""
    
    IMMEDIATE_SIGNALS = [
        "stop", "hang up", "disconnect", "end call",
        "ruk", "band karo", "bye"
    ]
    
    SAFETY_SIGNALS = [
        "driving", "drive", "car", "road",
        "emergency", "hospital", "urgent"
    ]
    
    TEMPORAL_SIGNALS = [
        "busy", "meeting", "class", "lecture",
        "not now", "can't talk", "call later",
        "call back", "another time", "bad time",
        "abhi nahi", "baad mein", "busy hun"
    ]
    
    IMPLICIT_SIGNALS = [
        "have to go", "need to go", "gotta go",
        "running late", "in the middle of",
        "jaana hai", "chalna hai"
    ]
    
    def __init__(self):
        self.override_detected = False
        self.override_type = None
    
    def check_for_override(self, transcript: str) -> dict:
        """Check transcript for override signals"""
        transcript_lower = transcript.lower()
        
        # Check by priority order
        for signal in self.IMMEDIATE_SIGNALS:
            if signal in transcript_lower:
                return {
                    "detected": True,
                    "type": "immediate",
                    "signal": signal,
                    "action": "close_now"
                }
        
        for signal in self.SAFETY_SIGNALS:
            if signal in transcript_lower:
                return {
                    "detected": True,
                    "type": "safety",
                    "signal": signal,
                    "action": "close_now"
                }
        
        for signal in self.TEMPORAL_SIGNALS:
            if signal in transcript_lower:
                return {
                    "detected": True,
                    "type": "temporal",
                    "signal": signal,
                    "action": "ask_callback_only"
                }
        
        for signal in self.IMPLICIT_SIGNALS:
            if signal in transcript_lower:
                return {
                    "detected": True,
                    "type": "implicit",
                    "signal": signal,
                    "action": "close_politely"
                }
        
        return {"detected": False}
    
    def get_override_response(self, override_info: dict,
                               language: str) -> str:
        """Generate appropriate override response"""
        action = override_info["action"]
        
        responses = {
            "close_now": {
                "english": "No problem, bye!",
                "hindi": "कोई बात नहीं, bye!",
                "hinglish": "No problem, bye!"
            },
            "ask_callback_only": {
                "english": "Got it! Evening or weekend better for a callback?",
                "hindi": "समझ गया! Evening या weekend—कब call करूं?",
                "hinglish": "Got it! Evening ya weekend better?"
            },
            "close_politely": {
                "english": "Sure, no worries. Take care!",
                "hindi": "ठीक है, कोई बात नहीं। Bye!",
                "hinglish": "Sure, no worries. Bye!"
            }
        }
        
        return responses.get(action, {}).get(
            language, responses[action]["english"]
        )
    
    def should_skip_to_close(self, override_info: dict) -> bool:
        """Determine if we should skip remaining flow"""
        skip_actions = ["close_now", "close_politely"]
        return override_info.get("action") in skip_actions


class ConversationFlow:
    """Flow with override handling"""
    
    def __init__(self):
        self.override_handler = OverrideHandler()
        self.current_step = "opening"
    
    def process_turn(self, caller_input: str, 
                     context: dict) -> dict:
        # ALWAYS check for override first
        override = self.override_handler.check_for_override(
            caller_input
        )
        
        if override["detected"]:
            # Skip normal flow
            if self.override_handler.should_skip_to_close(override):
                return {
                    "response": self.override_handler.get_override_response(
                        override, context.get("language", "english")
                    ),
                    "next_step": "close",
                    "intent": "callback" if override["type"] == "temporal" 
                              else "unable_to_continue"
                }
            
            # For temporal, ask callback preference only
            if override["action"] == "ask_callback_only":
                return {
                    "response": self.override_handler.get_override_response(
                        override, context.get("language", "english")
                    ),
                    "next_step": "capture_callback",
                    "skip_pitch": True
                }
        
        # Normal flow processing
        return self.normal_flow(caller_input, context)

instructions: |
  ## OVERRIDE RULES (CHECK EVERY TURN - HIGHEST PRIORITY)
  
  If caller says ANY of these, STOP IMMEDIATELY:
  - "busy", "meeting", "class", "not now", "can't talk"
  - "call later", "call back", "another time"
  - "driving", "emergency"
  - "stop", "hang up"
  
  When override detected:
  1. STOP current pitch/question immediately
  2. Do NOT add "just one thing" or "quickly"
  3. For "busy/later" → Ask ONLY: "Evening or weekend better?"
  4. For "driving/stop" → Say only "No problem, bye!"
  5. Do NOT ask any other question after override
  
  The override check happens BEFORE any other processing.
  A single "busy" anywhere in their response = override.