Monologue Without Engagement

class MonologuePreventer:
    """Prevent long monologues in responses"""
    
    MAX_ITEMS_PER_CHUNK = 3
    MAX_SECONDS = 15
    WORDS_PER_SECOND = 2.5
    
    ENGAGEMENT_PHRASES = [
        "Sound good so far?",
        "Does that make sense?",
        "Want me to continue?",
        "Should I go on?",
        "Got it so far?",
        "Any questions on that?"
    ]
    
    EXPANSION_OFFERS = [
        "Want me to elaborate on any of those?",
        "Which one would you like to hear more about?",
        "Should I go into more detail on something?",
        "Any of those you'd like me to explain further?"
    ]
    
    def chunk_list(self, items: list, intro: str = None) -> list:
        """Break list into voice-friendly chunks"""
        chunks = []
        
        for i in range(0, len(items), self.MAX_ITEMS_PER_CHUNK):
            chunk_items = items[i:i + self.MAX_ITEMS_PER_CHUNK]
            
            if i == 0 and intro:
                chunk = f"{intro} First, {self.format_chunk(chunk_items)}"
            else:
                chunk = f"Next, {self.format_chunk(chunk_items)}"
            
            # Add engagement check
            chunk += f" {random.choice(self.ENGAGEMENT_PHRASES)}"
            chunks.append(chunk)
        
        return chunks
    
    def format_chunk(self, items: list) -> str:
        """Format items for voice"""
        if len(items) == 1:
            return items[0]
        elif len(items) == 2:
            return f"{items[0]} and {items[1]}"
        else:
            return f"{items[0]}, {items[1]}, and {items[2]}"
    
    def check_response_length(self, response: str) -> dict:
        """Check if response is too long"""
        words = len(response.split())
        estimated_seconds = words / self.WORDS_PER_SECOND
        
        if estimated_seconds > self.MAX_SECONDS:
            return {
                "too_long": True,
                "estimated_seconds": estimated_seconds,
                "recommendation": "Chunk response with engagement breaks"
            }
        
        return {"too_long": False}
    
    def add_engagement_break(self, response: str) -> str:
        """Add engagement check to long response"""
        sentences = re.split(r'(?<=[.!?])\s+', response)
        
        if len(sentences) <= 3:
            return response
        
        # Insert engagement check after third sentence
        sentences.insert(3, random.choice(self.ENGAGEMENT_PHRASES))
        
        return ' '.join(sentences)


class OptionsPresenter:
    """Present options in digestible chunks"""
    
    MAX_OPTIONS_PER_TURN = 3
    
    def present_time_slots(self, slots: list) -> str:
        """Present time slots in chunks"""
        if len(slots) <= 3:
            return self.format_options(slots)
        
        # Split into morning/afternoon if applicable
        morning = [s for s in slots if self.is_morning(s)]
        afternoon = [s for s in slots if not self.is_morning(s)]
        
        if morning and afternoon:
            return (f"I have some morning slots like {self.format_options(morning[:2])}, "
                   f"or afternoon like {self.format_options(afternoon[:2])}. "
                   f"Which works better for you?")
        else:
            return (f"I have {self.format_options(slots[:3])}. "
                   f"Any of those work, or want other options?")
    
    def is_morning(self, slot: str) -> bool:
        """Check if slot is morning"""
        hour = int(re.search(r'(\d+)', slot).group(1))
        return hour < 12
    
    def format_options(self, options: list) -> str:
        """Format options for voice"""
        if len(options) == 1:
            return options[0]
        elif len(options) == 2:
            return f"{options[0]} or {options[1]}"
        else:
            return f"{options[0]}, {options[1]}, or {options[2]}"
    
    def narrow_options(self, all_options: list, 
                       preference: str) -> list:
        """Narrow options based on preference"""
        if "morning" in preference.lower():
            return [o for o in all_options if self.is_morning(o)][:3]
        elif "afternoon" in preference.lower():
            return [o for o in all_options if not self.is_morning(o)][:3]
        return all_options[:3]


class PolicyExplainer:
    """Explain policies without monologue"""
    
    def explain_with_questions(self, policy_topic: str) -> str:
        """Start with clarifying question"""
        clarifiers = {
            "returns": "Sure! Are you looking to return something, "
                      "or just want to know the general policy?",
            "shipping": "Of course! Are you asking about shipping time "
                       "or shipping cost?",
            "pricing": "Happy to help! Are you comparing plans, or "
                      "asking about a specific feature's cost?",
            "default": "Sure! What specifically about that would "
                      "you like to know?"
        }
        return clarifiers.get(policy_topic, clarifiers["default"])
    
    def give_targeted_answer(self, specific_question: str, 
                             full_policy: dict) -> str:
        """Give targeted answer, not full dump"""
        # Only include relevant portion
        # Then offer to elaborate on other aspects
        
        relevant = self.extract_relevant(specific_question, full_policy)
        
        if len(relevant) <= 2:
            answer = self.format_answer(relevant)
            return f"{answer} Anything else about that?"
        else:
            # Still chunking if multiple relevant points
            answer = self.format_answer(relevant[:2])
            return (f"{answer} There's a bit more to it—want me "
                   f"to continue, or does that cover it?")

instructions: |
  ## AVOID MONOLOGUES
  
  In voice, information is fleeting. Callers lose track after 
  3-4 items.
  
  RULES:
  - Maximum 2-3 items before pausing for engagement
  - Maximum 15 seconds of continuous speech
  - Always check in: "Sound good so far?" / "Make sense?"
  - Offer to elaborate rather than info dump
  
  LISTING FEATURES:
  WRONG: "Our plan includes X, Y, Z, A, B, C, D, E, and F."
  RIGHT: "Our plan has three main benefits: X, Y, and Z. 
          Sound good? Want me to cover the rest?"
  
  GIVING STEPS:
  WRONG: "First do A, then B, then C, then D, then E..."
  RIGHT: "Okay, first do A, then B. Got it? [wait] Great, 
          now do C. After that I'll walk you through the rest."
  
  OFFERING OPTIONS:
  WRONG: "I have 9am, 10am, 10:30, 11am, 2pm, 2:30, 3pm..."
  RIGHT: "I have morning or afternoon—which works better?"
  
  EXPLAINING POLICIES:
  WRONG: [Full 30-second policy dump]
  RIGHT: "What specifically about returns do you need to know?"
  
  TURN BUDGET:
  Keep responses to approximately 7-9 turns total. A couple 
  extra turns for rapport is fine, but don't let it become 
  an interview.