Text Prompt Voice Failure

class VoiceResponseAdapter:
    """Adapt text-style responses for voice"""
    
    MAX_SENTENCES = 3
    MAX_CHARACTERS = 200
    
    FORMATTING_PATTERNS = [
        (r'\*\*([^*]+)\*\*', r'\1'),      # Bold
        (r'\*([^*]+)\*', r'\1'),           # Italic
        (r'^#{1,6}\s+', ''),               # Headers
        (r'^[-*]\s+', ''),                 # Bullets
        (r'^\d+\.\s+', ''),                # Numbered lists
        (r'\[([^\]]+)\]\([^)]+\)', r'\1'), # Links
        (r'`([^`]+)`', r'\1'),             # Code
        (r'```[\s\S]*?```', ''),           # Code blocks
    ]
    
    TEXT_PHRASES_TO_REMOVE = [
        "As an AI assistant",
        "As an AI",
        "Based on my training",
        "I don't have real-time access",
        "Here are the key points:",
        "Let me break this down:",
    ]
    
    def adapt(self, text_response: str) -> str:
        """Adapt text response for voice"""
        response = text_response
        
        # Remove formatting
        response = self.strip_formatting(response)
        
        # Remove text-style phrases
        response = self.remove_text_phrases(response)
        
        # Truncate if too long
        response = self.enforce_length(response)
        
        # Make conversational
        response = self.make_conversational(response)
        
        return response
    
    def strip_formatting(self, text: str) -> str:
        """Remove markdown and other formatting"""
        result = text
        for pattern, replacement in self.FORMATTING_PATTERNS:
            result = re.sub(pattern, replacement, result, flags=re.MULTILINE)
        return result.strip()
    
    def remove_text_phrases(self, text: str) -> str:
        """Remove phrases that sound weird in voice"""
        result = text
        for phrase in self.TEXT_PHRASES_TO_REMOVE:
            result = result.replace(phrase, "")
        return result.strip()
    
    def enforce_length(self, text: str) -> str:
        """Enforce length limits"""
        sentences = re.split(r'(?<=[.!?])\s+', text)
        
        if len(sentences) <= self.MAX_SENTENCES:
            return text
        
        # Take first N sentences, add continuation
        truncated = ' '.join(sentences[:self.MAX_SENTENCES])
        
        if len(sentences) > self.MAX_SENTENCES:
            truncated += " Want me to continue?"
        
        return truncated
    
    def make_conversational(self, text: str) -> str:
        """Make text more conversational"""
        replacements = [
            ("Therefore, ", "So "),
            ("However, ", "But "),
            ("Additionally, ", "Also, "),
            ("Furthermore, ", "And "),
            ("In conclusion, ", "So basically, "),
            ("It is important to note that ", "Just so you know, "),
        ]
        
        result = text
        for formal, casual in replacements:
            result = result.replace(formal, casual)
        
        return result


class ListChunker:
    """Chunk lists for voice delivery"""
    
    MAX_ITEMS_PER_TURN = 2
    
    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_TURN):
            chunk_items = items[i:i + self.MAX_ITEMS_PER_TURN]
            
            if i == 0 and intro:
                # First chunk with intro
                chunk = f"{intro} First, {self.format_items(chunk_items)}"
            elif i + self.MAX_ITEMS_PER_TURN >= len(items):
                # Last chunk
                chunk = f"And finally, {self.format_items(chunk_items)}"
            else:
                # Middle chunks
                chunk = f"Next, {self.format_items(chunk_items)}"
            
            chunk += " Got it?"
            chunks.append(chunk)
        
        return chunks
    
    def format_items(self, items: list) -> str:
        """Format items for voice"""
        if len(items) == 1:
            return items[0]
        elif len(items) == 2:
            return f"{items[0]}. And then {items[1]}"
        else:
            return '. '.join(items)


class VoicePromptValidator:
    """Validate prompts are voice-appropriate"""
    
    TEXT_ANTIPATTERNS = [
        r'\*\*',                    # Bold markdown
        r'^#+\s',                   # Headers
        r'^[-*]\s',                 # Bullets
        r'^\d+\.\s.*\n\d+\.',       # Consecutive numbered items
        r'As an AI',                # AI hedging
        r'```',                     # Code blocks
        r'\|.*\|.*\|',              # Tables
    ]
    
    def validate(self, prompt: str) -> dict:
        """Check if prompt is voice-appropriate"""
        issues = []
        
        for pattern in self.TEXT_ANTIPATTERNS:
            matches = re.findall(pattern, prompt, re.MULTILINE)
            if matches:
                issues.append({
                    "pattern": pattern,
                    "matches": len(matches),
                    "issue": "Text formatting in voice prompt"
                })
        
        # Check example responses in prompt
        if "Example:" in prompt or "Response:" in prompt:
            # Extract examples and check them
            examples = re.findall(
                r'(?:Example|Response):\s*["\']?([^"\']+)["\']?',
                prompt
            )
            for ex in examples:
                if len(ex) > 200:
                    issues.append({
                        "issue": "Example response too long for voice",
                        "length": len(ex)
                    })
        
        return {
            "voice_appropriate": len(issues) == 0,
            "issues": issues
        }

instructions: |
  ## VOICE-SPECIFIC PROMPTING
  
  This is a VOICE agent, not a text chatbot.
  
  NEVER output:
  - Markdown (**bold**, *italic*, # headers)
  - Bullet points (- or *)
  - Numbered lists with more than 2 items at once
  - "As an AI assistant" or similar hedging
  - Multi-paragraph explanations
  
  RESPONSE LENGTH:
  - Maximum 2-3 sentences per turn
  - If more info needed, ask "Want me to continue?"
  - Break lists into chunks with confirmation
  
  FOR LISTS/STEPS:
  
  WRONG (text style):
  "Here are the 5 steps:
   1. Do this
   2. Do that
   3. Do another thing
   4. Do more
   5. Finally this"
  
  RIGHT (voice style):
  "Okay, there are 5 steps. Let me walk you through.
   First, do this. Second, do that. Got it?"
  [Wait for yes]
  "Great. Third, do another thing. Fourth, do more. Still with me?"
  [Wait for yes]
  "Perfect. And last, finally this. Any questions?"
  
  CONVERSATIONAL PHRASING:
  - "So basically..." instead of "In conclusion,"
  - "Just so you know..." instead of "It is important to note"
  - "But" instead of "However"
  
  REMEMBER: Caller can't scroll back. Information is fleeting.