Opening Timing Mismatch

class OpeningManager:
    """Manage dynamic conversation openings"""
    
    GREETING_PATTERNS = [
        "hello", "hi", "hey", "haan", "yes", "speaking",
        "bolo", "haan bolo", "ji"
    ]
    
    QUESTION_PATTERNS = [
        "who is this", "kaun", "kon bol raha", 
        "who's calling", "kahan se"
    ]
    
    CURT_PATTERNS = [
        "yeah", "what", "haan", "bol", "bolo"
    ]
    
    OPENING_TEMPLATES = {
        "standard": (
            "Hi! This is Riya from Zapp Chess—you had filled "
            "the Campus Ambassador form. Got a minute?"
        ),
        "after_hello": (
            "Hi! This is Riya from Zapp Chess, calling about "
            "the Campus Ambassador form you filled. Got a sec?"
        ),
        "answer_who": (
            "This is Riya from Zapp Chess—the chess app. "
            "You'd filled our Campus Ambassador form. "
            "Is this a good time?"
        ),
        "curt_match": (
            "Hey, Riya from Zapp Chess—about the ambassador "
            "form. Got a minute?"
        ),
        "no_greeting": (
            "Hi! This is Riya from Zapp Chess..."
        )
    }
    
    def __init__(self, wait_for_caller=True, max_wait_ms=1500):
        self.wait_for_caller = wait_for_caller
        self.max_wait_ms = max_wait_ms
    
    def analyze_caller_opening(self, transcript: str) -> dict:
        """Analyze caller's first utterance"""
        if not transcript or transcript.strip() == "":
            return {"type": "no_greeting", "tone": "neutral"}
        
        transcript_lower = transcript.lower().strip()
        
        # Check for question
        if any(q in transcript_lower for q in self.QUESTION_PATTERNS):
            return {"type": "question", "tone": "curious"}
        
        # Check for curt response
        if (len(transcript_lower.split()) <= 2 and 
            any(c in transcript_lower for c in self.CURT_PATTERNS)):
            return {"type": "greeting", "tone": "curt"}
        
        # Check for greeting
        if any(g in transcript_lower for g in self.GREETING_PATTERNS):
            return {"type": "greeting", "tone": "neutral"}
        
        return {"type": "unknown", "tone": "neutral"}
    
    def get_opening(self, caller_opening: dict) -> str:
        """Get appropriate opening based on caller's state"""
        opening_type = caller_opening.get("type", "no_greeting")
        tone = caller_opening.get("tone", "neutral")
        
        if opening_type == "question":
            return self.OPENING_TEMPLATES["answer_who"]
        
        if opening_type == "greeting" and tone == "curt":
            return self.OPENING_TEMPLATES["curt_match"]
        
        if opening_type == "greeting":
            return self.OPENING_TEMPLATES["after_hello"]
        
        return self.OPENING_TEMPLATES["standard"]
    
    def should_yield(self, caller_speaking: bool, 
                     agent_speaking: bool) -> bool:
        """Determine if agent should yield to caller"""
        # If both speaking, agent yields
        return caller_speaking and agent_speaking


class CallFlowManager:
    """Manage call connection and opening"""
    
    def __init__(self):
        self.opening_manager = OpeningManager()
    
    async def handle_call_connect(self, call_context: dict) -> dict:
        """Handle initial call connection"""
        
        # Wait briefly for caller to speak first
        caller_utterance = await self.wait_for_caller_speech(
            timeout_ms=1500
        )
        
        # Analyze what caller said (if anything)
        caller_analysis = self.opening_manager.analyze_caller_opening(
            caller_utterance
        )
        
        # Get appropriate opening
        opening = self.opening_manager.get_opening(caller_analysis)
        
        return {
            "agent_opening": opening,
            "caller_state": caller_analysis,
            "delay_ms": 200 if caller_utterance else 800
        }
    
    async def wait_for_caller_speech(self, timeout_ms: int) -> str:
        """Wait for caller's first utterance"""
        # Implementation depends on voice platform
        # Returns transcript if caller spoke, empty string if timeout
        pass

instructions: |
  ## OPENING RULES
  
  The call should NOT sound like it starts mid-pickup.
  
  IF the caller has already greeted (said "hello", "hi", etc):
  → Respond naturally to their greeting before your opening
  → Example: Caller: "Hello?" → "Hi! This is Riya from..."
  
  IF the caller asks "who is this?":
  → Answer the question first
  → "This is Riya from Zapp Chess—the chess app."
  → Then continue with purpose of call
  
  IF the caller sounds curt ("yeah", "what"):
  → Match their energy—be brief, not over-enthusiastic
  → "Hey, Riya from Zapp Chess—about the ambassador form."
  
  IF there's overlap (both start talking):
  → Yield to the caller
  → Wait for them to finish, then respond
  
  TONE MATCHING:
  - Enthusiastic caller → Warm and upbeat
  - Neutral caller → Friendly and professional  
  - Curt/busy caller → Brief and direct