Call Disconnection Handling

class DisconnectionHandler:
    """Handle call disconnections gracefully"""
    
    DISCONNECT_TYPES = {
        "clean_end": {
            "signals": ["goodbye detected", "thank you + silence"],
            "action": "normal_close",
            "callback": False
        },
        "network_drop": {
            "signals": ["mid-word silence", "sudden cut"],
            "action": "save_and_callback",
            "callback": True,
            "priority": "high"
        },
        "accidental": {
            "signals": ["mid-conversation silence", "no goodbye"],
            "action": "save_and_callback",
            "callback": True,
            "priority": "medium"
        },
        "frustrated": {
            "signals": ["after_objection", "abrupt after negative"],
            "action": "save_no_callback",
            "callback": False,
            "cooldown": "24h"
        }
    }
    
    def __init__(self, silence_threshold_ms=3000):
        self.silence_threshold = silence_threshold_ms
        self.last_audio_timestamp = None
        self.conversation_state = {}
    
    def monitor_connection(self, audio_stream) -> dict:
        """Monitor for disconnection"""
        silence_duration = self.get_silence_duration(audio_stream)
        
        if silence_duration > self.silence_threshold:
            disconnect_type = self.classify_disconnect()
            return {
                "disconnected": True,
                "type": disconnect_type,
                "action": self.DISCONNECT_TYPES[disconnect_type]["action"],
                "data_to_save": self.get_conversation_state()
            }
        
        return {"disconnected": False}
    
    def classify_disconnect(self) -> str:
        """Classify type of disconnection"""
        # Check last message sentiment
        if self.last_message_was_negative():
            return "frustrated"
        
        # Check if goodbye was said
        if self.goodbye_detected():
            return "clean_end"
        
        # Check if mid-word
        if self.was_mid_utterance():
            return "network_drop"
        
        return "accidental"
    
    def handle_disconnect(self, disconnect_type: str) -> dict:
        """Handle disconnection appropriately"""
        config = self.DISCONNECT_TYPES.get(disconnect_type)
        
        # Always save partial data
        saved_data = self.save_partial_conversation()
        
        result = {
            "saved_data": saved_data,
            "outcome": f"disconnected_{disconnect_type}",
        }
        
        # Trigger callback if appropriate
        if config.get("callback"):
            result["callback"] = {
                "trigger": True,
                "priority": config.get("priority", "medium"),
                "delay": "5_minutes" if disconnect_type == "network_drop" 
                        else "1_hour"
            }
        
        return result
    
    def save_partial_conversation(self) -> dict:
        """Save all captured data before disconnect"""
        return {
            "timestamp": datetime.now(),
            "progress_percentage": self.calculate_progress(),
            "captured_fields": self.conversation_state,
            "last_step": self.current_step,
            "last_agent_message": self.last_agent_message,
            "last_caller_message": self.last_caller_message,
            "disconnect_point": self.get_disconnect_point()
        }


class CallbackManager:
    """Manage callbacks for disconnected calls"""
    
    def __init__(self):
        self.callback_queue = []
    
    def schedule_callback(self, call_data: dict, 
                          priority: str,
                          delay: str) -> dict:
        """Schedule a callback for disconnected call"""
        callback = {
            "original_call_id": call_data.get("call_id"),
            "phone_number": call_data.get("phone_number"),
            "saved_state": call_data.get("saved_data"),
            "priority": priority,
            "scheduled_time": self.calculate_callback_time(delay),
            "attempt": 1,
            "max_attempts": 2,
            "resume_from": call_data.get("last_step")
        }
        
        self.callback_queue.append(callback)
        return callback
    
    def get_callback_opening(self, saved_state: dict) -> str:
        """Generate opening for callback based on prior context"""
        progress = saved_state.get("progress_percentage", 0)
        
        if progress > 70:
            return ("Hey, we got disconnected earlier! You were "
                   "almost done—can we finish up real quick?")
        elif progress > 30:
            return ("Hey, our call got cut off. You seemed "
                   "interested—got a minute to continue?")
        else:
            return ("Hey, we got disconnected earlier. "
                   "Is now a better time?")

instructions: |
  ## DISCONNECTION HANDLING
  
  If caller suddenly goes silent mid-conversation:
  
  1. DETECT quickly (< 3 seconds of silence)
  2. DO NOT continue talking to empty line
  3. CLASSIFY the disconnect:
     - Clean end: They said bye first
     - Accidental/Network: Mid-sentence or mid-conversation
     - Frustrated: After negative response
  
  4. SAVE all captured data immediately:
     - Interest level
     - Any permissions given
     - College name if captured
     - Last step completed
  
  5. OUTCOME should reflect disconnect:
     - "disconnected_callback" (if need callback)
     - "disconnected_complete" (if was finishing)
     - "disconnected_frustrated" (if after objection)
  
  On CALLBACK to disconnected caller:
  - Acknowledge the disconnect
  - Don't start from scratch
  - "Hey, we got cut off! You were interested—want to continue?"