Fix spacing for CJK languages

changelog/3489.fixed.md

@@ -1 +1,3 @@
-- Fixed `AzureTTSService` transcript formatting where punctuation appeared with extra spaces (e.g., "Hello !" instead of "Hello!"). Azure sends punctuation as separate word boundaries, which are now merged with preceding words to produce properly formatted transcripts across all languages.
+- Fixed `AzureTTSService` transcript formatting issues:
+  - Punctuation now appears without extra spaces (e.g., "Hello!" instead of "Hello !")
+  - CJK languages (Chinese, Japanese, Korean) no longer have unwanted spaces between characters

src/pipecat/services/azure/tts.py

@@ -348,6 +348,16 @@ class AzureTTSService(WordTTSService, AzureBaseTTSService):
         await self.cancel_task(self._word_processor_task)
         self._word_processor_task = None
 
+    def _is_cjk_language(self) -> bool:
+        """Check if the configured language is CJK (Chinese, Japanese, Korean).
+
+        Returns:
+            True if the language is CJK, False otherwise.
+        """
+        language = self._settings.get("language", "").lower()
+        # Check if language starts with CJK language codes
+        return language.startswith(("zh", "ja", "ko", "cmn", "yue", "wuu"))
+
     def _is_punctuation_only(self, text: str) -> bool:
         """Check if text consists only of punctuation and whitespace.
 
@@ -362,9 +372,9 @@ class AzureTTSService(WordTTSService, AzureBaseTTSService):
     def _handle_word_boundary(self, evt):
         """Handle word boundary events from Azure SDK.
 
-        Azure sends punctuation as separate word boundaries, which causes
-        spacing issues in the final transcript. This method merges punctuation
-        with the previous word to maintain proper formatting.
+        Azure sends punctuation as separate word boundaries, and breaks CJK text
+        into individual characters/particles. This method routes to language-specific
+        handlers to properly merge and emit word boundaries.
 
         Args:
             evt: SpeechSynthesisWordBoundaryEventArgs from Azure Speech SDK
@@ -382,20 +392,72 @@ class AzureTTSService(WordTTSService, AzureBaseTTSService):
         if not word:
             return
 
-        # Check if this is punctuation-only
-        is_punctuation = self._is_punctuation_only(word)
-
-        if is_punctuation and self._last_word is not None:
-            # Merge punctuation with the previous word (don't queue yet, more punctuation might follow)
-            self._last_word += word
+        # Route to language-specific handler
+        if self._is_cjk_language():
+            self._handle_cjk_word_boundary(word, absolute_seconds)
         else:
-            # This is a real word. First, queue any pending word from before.
-            if self._last_word is not None:
-                self._word_boundary_queue.put_nowait((self._last_word, self._last_timestamp))
+            self._handle_non_cjk_word_boundary(word, absolute_seconds)
 
-            # Now store this new word for next time
+    def _emit_pending_word(self):
+        """Emit the currently buffered word if one exists."""
+        if self._last_word is not None:
+            self._word_boundary_queue.put_nowait((self._last_word, self._last_timestamp))
+            self._last_word = None
+            self._last_timestamp = None
+
+    def _handle_cjk_word_boundary(self, word: str, timestamp: float):
+        """Handle word boundaries for CJK languages (Chinese, Japanese, Korean).
+
+        CJK languages don't use spaces between words, so we merge characters together
+        and only emit at natural break points (punctuation or whitespace boundaries).
+        Without this logic, we don't get word output for CJK languages.
+
+        Args:
+            word: The word/character from Azure.
+            timestamp: Timestamp in seconds.
+        """
+        # First word: just store it
+        if self._last_word is None:
             self._last_word = word
-            self._last_timestamp = absolute_seconds
+            self._last_timestamp = timestamp
+            return
+
+        # Punctuation: merge and emit (natural break)
+        if self._is_punctuation_only(word):
+            self._last_word += word
+            self._emit_pending_word()
+            return
+
+        # Whitespace: emit before boundary, start new segment
+        if word.strip() != word:
+            self._emit_pending_word()
+            self._last_word = word
+            self._last_timestamp = timestamp
+            return
+
+        # Default: continue merging CJK characters
+        self._last_word += word
+
+    def _handle_non_cjk_word_boundary(self, word: str, timestamp: float):
+        """Handle word boundaries for non-CJK languages.
+
+        Non-CJK languages use spaces between words, so we emit each word separately
+        after merging any trailing punctuation.
+
+        Args:
+            word: The word from Azure.
+            timestamp: Timestamp in seconds.
+        """
+        # Punctuation: merge with previous word (don't emit yet)
+        if self._is_punctuation_only(word) and self._last_word is not None:
+            self._last_word += word
+            return
+
+        # Regular word: emit previous, store current
+        if self._last_word is not None:
+            self._word_boundary_queue.put_nowait((self._last_word, self._last_timestamp))
+        self._last_word = word
+        self._last_timestamp = timestamp
 
     async def _word_processor_task_handler(self):
         """Process word timestamps from the queue and call add_word_timestamps."""