Spoken Form Failures

class SpokenFormConverter:
    """Convert written forms to spoken forms"""
    
    def convert(self, text: str) -> str:
        """Convert all formatted content to spoken form"""
        result = text
        
        # Convert phone numbers
        result = self.convert_phone_numbers(result)
        
        # Convert dates
        result = self.convert_dates(result)
        
        # Convert currency
        result = self.convert_currency(result)
        
        # Convert times
        result = self.convert_times(result)
        
        # Convert addresses
        result = self.convert_addresses(result)
        
        # Convert plain numbers
        result = self.convert_numbers(result)
        
        return result
    
    def convert_phone_numbers(self, text: str) -> str:
        """Convert phone numbers to spoken form"""
        # Pattern for various phone formats
        phone_pattern = r'\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'
        
        def phone_to_spoken(match):
            digits = re.sub(r'\D', '', match.group())
            # Group as: XXX, XXX, XXXX
            return (f"{self.digits_to_words(digits[:3])}, "
                   f"{self.digits_to_words(digits[3:6])}, "
                   f"{self.digits_to_words(digits[6:])}")
        
        return re.sub(phone_pattern, phone_to_spoken, text)
    
    def digits_to_words(self, digits: str) -> str:
        """Convert digit string to spoken words"""
        words = {
            '0': 'zero', '1': 'one', '2': 'two', '3': 'three',
            '4': 'four', '5': 'five', '6': 'six', '7': 'seven',
            '8': 'eight', '9': 'nine'
        }
        return ' '.join(words[d] for d in digits)
    
    def convert_dates(self, text: str) -> str:
        """Convert dates to spoken form"""
        months = {
            '01': 'January', '02': 'February', '03': 'March',
            '04': 'April', '05': 'May', '06': 'June',
            '07': 'July', '08': 'August', '09': 'September',
            '10': 'October', '11': 'November', '12': 'December'
        }
        
        ordinals = {
            '1': 'first', '2': 'second', '3': 'third', '4': 'fourth',
            '5': 'fifth', '6': 'sixth', '7': 'seventh', '8': 'eighth',
            '9': 'ninth', '10': 'tenth', '11': 'eleventh', '12': 'twelfth',
            '13': 'thirteenth', '14': 'fourteenth', '15': 'fifteenth',
            '16': 'sixteenth', '17': 'seventeenth', '18': 'eighteenth',
            '19': 'nineteenth', '20': 'twentieth', '21': 'twenty-first',
            '22': 'twenty-second', '23': 'twenty-third', '24': 'twenty-fourth',
            '25': 'twenty-fifth', '26': 'twenty-sixth', '27': 'twenty-seventh',
            '28': 'twenty-eighth', '29': 'twenty-ninth', '30': 'thirtieth',
            '31': 'thirty-first'
        }
        
        # MM/DD/YYYY pattern
        def date_to_spoken(match):
            month = months.get(match.group(1), match.group(1))
            day = ordinals.get(match.group(2).lstrip('0'), match.group(2))
            year = self.year_to_spoken(match.group(3))
            return f"{month} {day}, {year}"
        
        return re.sub(r'(\d{2})/(\d{2})/(\d{4})', date_to_spoken, text)
    
    def year_to_spoken(self, year: str) -> str:
        """Convert year to spoken form"""
        if year.startswith('20'):
            # 2025 → "twenty twenty-five"
            first = int(year[:2])
            second = int(year[2:])
            return f"twenty {self.number_to_words(second)}"
        return year
    
    def convert_currency(self, text: str) -> str:
        """Convert currency to spoken form"""
        def currency_to_spoken(match):
            amount = match.group(1)
            parts = amount.split('.')
            dollars = int(parts[0])
            cents = int(parts[1]) if len(parts) > 1 else 0
            
            result = f"{self.number_to_words(dollars)} dollar"
            if dollars != 1:
                result += "s"
            
            if cents > 0:
                result += f" and {self.number_to_words(cents)} cent"
                if cents != 1:
                    result += "s"
            
            return result
        
        return re.sub(r'\$(\d+\.?\d*)', currency_to_spoken, text)
    
    def convert_times(self, text: str) -> str:
        """Convert times to spoken form"""
        def time_to_spoken(match):
            hour = int(match.group(1))
            minute = int(match.group(2))
            period = match.group(3).upper()
            
            hour_word = self.number_to_words(hour)
            
            if minute == 0:
                time_str = hour_word
            elif minute < 10:
                time_str = f"{hour_word} oh {self.number_to_words(minute)}"
            else:
                time_str = f"{hour_word} {self.number_to_words(minute)}"
            
            period_word = "in the morning" if period == "AM" else "in the afternoon"
            
            return f"{time_str} {period_word}"
        
        return re.sub(r'(\d{1,2}):(\d{2})\s*(AM|PM|am|pm)', 
                     time_to_spoken, text)
    
    def convert_addresses(self, text: str) -> str:
        """Convert address abbreviations"""
        replacements = {
            r'\bSt\b': 'Street',
            r'\bAve\b': 'Avenue',
            r'\bBlvd\b': 'Boulevard',
            r'\bDr\b': 'Drive',
            r'\bLn\b': 'Lane',
            r'\bSte\b': 'Suite',
            r'\bApt\b': 'Apartment',
        }
        
        result = text
        for pattern, replacement in replacements.items():
            result = re.sub(pattern, replacement, result)
        
        return result
    
    def convert_numbers(self, text: str) -> str:
        """Convert standalone numbers to spoken form"""
        # Only convert certain contexts (like "Suite 400")
        def suite_to_spoken(match):
            return f"Suite {self.number_to_words(int(match.group(1)))}"
        
        return re.sub(r'Suite (\d+)', suite_to_spoken, text)
    
    def number_to_words(self, n: int) -> str:
        """Convert number to words"""
        if n < 20:
            words = ['zero', 'one', 'two', 'three', 'four', 'five',
                    'six', 'seven', 'eight', 'nine', 'ten', 'eleven',
                    'twelve', 'thirteen', 'fourteen', 'fifteen',
                    'sixteen', 'seventeen', 'eighteen', 'nineteen']
            return words[n]
        elif n < 100:
            tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty',
                   'sixty', 'seventy', 'eighty', 'ninety']
            if n % 10 == 0:
                return tens[n // 10]
            return f"{tens[n // 10]}-{self.number_to_words(n % 10)}"
        elif n < 1000:
            if n % 100 == 0:
                return f"{self.number_to_words(n // 100)} hundred"
            return (f"{self.number_to_words(n // 100)} hundred "
                   f"{self.number_to_words(n % 100)}")
        return str(n)  # Fallback for larger numbers

instructions: |
  ## Response Guidelines - Spoken Forms
  
  For dates, money, phone numbers, and formatted text, 
  use the SPOKEN form, not the written form.
  
  PHONE NUMBERS:
  Written: (555) 239-8123
  Spoken: "five five five, two three nine, eight one two three"
  
  DATES:
  Written: 03/04/2025
  Spoken: "March fourth, twenty twenty-five"
  
  CURRENCY:
  Written: $42.50
  Spoken: "forty-two dollars and fifty cents"
  
  TIMES:
  Written: 2:15 PM
  Spoken: "two fifteen in the afternoon"
  
  ADDRESSES:
  Written: 400 Main St, Suite 200
  Spoken: "four hundred Main Street, Suite two hundred"
  
  CONFIRMATION NUMBERS:
  Written: ABC123
  Spoken: "A B C one two three" (with pauses)
  
  NEVER output:
  - Slashes in dates (/)
  - Colons in times (:)
  - Dollar signs ($)
  - Parentheses in phone numbers
  - Abbreviated street names (St, Ave)
  
  When reading numbers back for confirmation, use natural 
  grouping with pauses to aid memory.