Migrate existing TTS providers to infrastructure layer

src/domain/models/speech_synthesis_request.py

@@ -10,7 +10,7 @@ from .voice_settings import VoiceSettings
 class SpeechSynthesisRequest:
     """Value object representing a speech synthesis request."""
     
-    text: TextContent
+    text_content: TextContent
     voice_settings: VoiceSettings
     output_format: str = 'wav'
     sample_rate: Optional[int] = None
@@ -21,7 +21,7 @@ class SpeechSynthesisRequest:
     
     def _validate(self):
         """Validate speech synthesis request properties."""
-        if not isinstance(self.text, TextContent):
+        if not isinstance(self.text_content, TextContent):
             raise TypeError("Text must be a TextContent instance")
         
         if not isinstance(self.voice_settings, VoiceSettings):
@@ -44,8 +44,8 @@ class SpeechSynthesisRequest:
                 raise ValueError("Sample rate must be between 8000 and 192000 Hz")
         
         # Validate that text and voice settings have compatible languages
-        if self.text.language != self.voice_settings.language:
-            raise ValueError(f"Text language ({self.text.language}) must match voice language ({self.voice_settings.language})")
+        if self.text_content.language != self.voice_settings.language:
+            raise ValueError(f"Text language ({self.text_content.language}) must match voice language ({self.voice_settings.language})")
     
     @property
     def estimated_duration_seconds(self) -> float:
@@ -53,12 +53,12 @@ class SpeechSynthesisRequest:
         # Rough estimation: average speaking rate is about 150-200 words per minute
         # Adjusted by speed setting
         words_per_minute = 175 / self.voice_settings.speed
-        return (self.text.word_count / words_per_minute) * 60
+        return (self.text_content.word_count / words_per_minute) * 60
     
     @property
     def is_long_text(self) -> bool:
         """Check if the text is considered long for TTS processing."""
-        return self.text.character_count > 5000
+        return self.text_content.character_count > 5000
     
     @property
     def effective_sample_rate(self) -> int:
@@ -68,7 +68,7 @@ class SpeechSynthesisRequest:
     def with_output_format(self, output_format: str) -> 'SpeechSynthesisRequest':
         """Create a new SpeechSynthesisRequest with different output format."""
         return SpeechSynthesisRequest(
-            text=self.text,
+            text_content=self.text_content,
             voice_settings=self.voice_settings,
             output_format=output_format,
             sample_rate=self.sample_rate
@@ -77,7 +77,7 @@ class SpeechSynthesisRequest:
     def with_sample_rate(self, sample_rate: Optional[int]) -> 'SpeechSynthesisRequest':
         """Create a new SpeechSynthesisRequest with different sample rate."""
         return SpeechSynthesisRequest(
-            text=self.text,
+            text_content=self.text_content,
             voice_settings=self.voice_settings,
             output_format=self.output_format,
             sample_rate=sample_rate
@@ -86,7 +86,7 @@ class SpeechSynthesisRequest:
     def with_voice_settings(self, voice_settings: VoiceSettings) -> 'SpeechSynthesisRequest':
         """Create a new SpeechSynthesisRequest with different voice settings."""
         return SpeechSynthesisRequest(
-            text=self.text,
+            text_content=self.text_content,
             voice_settings=voice_settings,
             output_format=self.output_format,
             sample_rate=self.sample_rate

src/infrastructure/tts/__init__.py

@@ -0,0 +1,28 @@
+"""TTS provider implementations."""
+
+from .provider_factory import TTSProviderFactory
+from .dummy_provider import DummyTTSProvider
+
+# Try to import optional providers
+try:
+    from .kokoro_provider import KokoroTTSProvider
+except ImportError:
+    KokoroTTSProvider = None
+
+try:
+    from .dia_provider import DiaTTSProvider
+except ImportError:
+    DiaTTSProvider = None
+
+try:
+    from .cosyvoice2_provider import CosyVoice2TTSProvider
+except ImportError:
+    CosyVoice2TTSProvider = None
+
+__all__ = [
+    'TTSProviderFactory',
+    'DummyTTSProvider',
+    'KokoroTTSProvider',
+    'DiaTTSProvider', 
+    'CosyVoice2TTSProvider'
+]

src/infrastructure/tts/cosyvoice2_provider.py

@@ -0,0 +1,159 @@
+"""CosyVoice2 TTS provider implementation."""
+
+import logging
+import numpy as np
+import soundfile as sf
+import io
+from typing import Iterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...domain.models.speech_synthesis_request import SpeechSynthesisRequest
+
+from ..base.tts_provider_base import TTSProviderBase
+from ...domain.exceptions import SpeechSynthesisException
+
+logger = logging.getLogger(__name__)
+
+# Flag to track CosyVoice2 availability
+COSYVOICE2_AVAILABLE = False
+DEFAULT_SAMPLE_RATE = 24000
+
+# Try to import CosyVoice2 dependencies
+try:
+    import torch
+    # Import CosyVoice2 - assuming it's installed and has a similar API to Dia
+    # since they're both from nari-labs according to the GitHub link
+    from cosyvoice2.model import CosyVoice2
+    COSYVOICE2_AVAILABLE = True
+    logger.info("CosyVoice2 TTS engine is available")
+except ImportError:
+    logger.warning("CosyVoice2 TTS engine is not available")
+except ModuleNotFoundError as e:
+    logger.warning(f"CosyVoice2 TTS engine is not available: {str(e)}")
+    COSYVOICE2_AVAILABLE = False
+
+
+class CosyVoice2TTSProvider(TTSProviderBase):
+    """CosyVoice2 TTS provider implementation."""
+
+    def __init__(self, lang_code: str = 'z'):
+        """Initialize the CosyVoice2 TTS provider."""
+        super().__init__(
+            provider_name="CosyVoice2",
+            supported_languages=['en', 'z']  # CosyVoice2 supports English and multilingual
+        )
+        self.lang_code = lang_code
+        self.model = None
+
+    def _ensure_model(self):
+        """Ensure the model is loaded."""
+        if self.model is None and COSYVOICE2_AVAILABLE:
+            try:
+                import torch
+                from cosyvoice2.model import CosyVoice2
+                self.model = CosyVoice2.from_pretrained()
+                logger.info("CosyVoice2 model successfully loaded")
+            except ImportError as e:
+                logger.error(f"Failed to import CosyVoice2 dependencies: {str(e)}")
+                self.model = None
+            except FileNotFoundError as e:
+                logger.error(f"Failed to load CosyVoice2 model files: {str(e)}")
+                self.model = None
+            except Exception as e:
+                logger.error(f"Failed to initialize CosyVoice2 model: {str(e)}")
+                self.model = None
+        return self.model is not None
+
+    def is_available(self) -> bool:
+        """Check if CosyVoice2 TTS is available."""
+        return COSYVOICE2_AVAILABLE and self._ensure_model()
+
+    def get_available_voices(self) -> list[str]:
+        """Get available voices for CosyVoice2."""
+        # CosyVoice2 typically uses a default voice
+        return ['default']
+
+    def _generate_audio(self, request: 'SpeechSynthesisRequest') -> tuple[bytes, int]:
+        """Generate audio using CosyVoice2 TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("CosyVoice2 TTS engine is not available")
+
+        try:
+            import torch
+            
+            # Extract parameters from request
+            text = request.text_content.text
+
+            # Generate audio using CosyVoice2
+            with torch.inference_mode():
+                # Assuming CosyVoice2 has a similar API to Dia
+                output_audio_np = self.model.generate(
+                    text,
+                    max_tokens=None,
+                    cfg_scale=3.0,
+                    temperature=1.3,
+                    top_p=0.95,
+                    use_torch_compile=False,
+                    verbose=False
+                )
+
+            if output_audio_np is None:
+                raise SpeechSynthesisException("CosyVoice2 model returned None for audio output")
+
+            # Convert numpy array to bytes
+            audio_bytes = self._numpy_to_bytes(output_audio_np, sample_rate=DEFAULT_SAMPLE_RATE)
+            return audio_bytes, DEFAULT_SAMPLE_RATE
+
+        except Exception as e:
+            self._handle_provider_error(e, "audio generation")
+
+    def _generate_audio_stream(self, request: 'SpeechSynthesisRequest') -> Iterator[tuple[bytes, int, bool]]:
+        """Generate audio stream using CosyVoice2 TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("CosyVoice2 TTS engine is not available")
+
+        try:
+            import torch
+            
+            # Extract parameters from request
+            text = request.text_content.text
+
+            # Generate audio using CosyVoice2
+            with torch.inference_mode():
+                # Assuming CosyVoice2 has a similar API to Dia
+                output_audio_np = self.model.generate(
+                    text,
+                    max_tokens=None,
+                    cfg_scale=3.0,
+                    temperature=1.3,
+                    top_p=0.95,
+                    use_torch_compile=False,
+                    verbose=False
+                )
+
+            if output_audio_np is None:
+                raise SpeechSynthesisException("CosyVoice2 model returned None for audio output")
+
+            # Convert numpy array to bytes
+            audio_bytes = self._numpy_to_bytes(output_audio_np, sample_rate=DEFAULT_SAMPLE_RATE)
+            # CosyVoice2 generates complete audio in one go
+            yield audio_bytes, DEFAULT_SAMPLE_RATE, True
+
+        except Exception as e:
+            self._handle_provider_error(e, "streaming audio generation")
+
+    def _numpy_to_bytes(self, audio_array: np.ndarray, sample_rate: int) -> bytes:
+        """Convert numpy audio array to bytes."""
+        try:
+            # Create an in-memory buffer
+            buffer = io.BytesIO()
+            
+            # Write audio data to buffer as WAV
+            sf.write(buffer, audio_array, sample_rate, format='WAV')
+            
+            # Get bytes from buffer
+            buffer.seek(0)
+            return buffer.read()
+            
+        except Exception as e:
+            raise SpeechSynthesisException(f"Failed to convert audio to bytes: {str(e)}") from e

src/infrastructure/tts/dia_provider.py

@@ -0,0 +1,170 @@
+"""Dia TTS provider implementation."""
+
+import logging
+import numpy as np
+import soundfile as sf
+import io
+from typing import Iterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...domain.models.speech_synthesis_request import SpeechSynthesisRequest
+
+from ..base.tts_provider_base import TTSProviderBase
+from ...domain.exceptions import SpeechSynthesisException
+
+logger = logging.getLogger(__name__)
+
+# Flag to track Dia availability
+DIA_AVAILABLE = False
+DEFAULT_SAMPLE_RATE = 24000
+
+# Try to import Dia dependencies
+try:
+    import torch
+    from dia.model import Dia
+    DIA_AVAILABLE = True
+    logger.info("Dia TTS engine is available")
+except ImportError:
+    logger.warning("Dia TTS engine is not available")
+except ModuleNotFoundError as e:
+    if "dac" in str(e):
+        logger.warning("Dia TTS engine is not available due to missing 'dac' module")
+    else:
+        logger.warning(f"Dia TTS engine is not available: {str(e)}")
+    DIA_AVAILABLE = False
+
+
+class DiaTTSProvider(TTSProviderBase):
+    """Dia TTS provider implementation."""
+
+    def __init__(self, lang_code: str = 'z'):
+        """Initialize the Dia TTS provider."""
+        super().__init__(
+            provider_name="Dia",
+            supported_languages=['en', 'z']  # Dia supports English and multilingual
+        )
+        self.lang_code = lang_code
+        self.model = None
+
+    def _ensure_model(self):
+        """Ensure the model is loaded."""
+        if self.model is None and DIA_AVAILABLE:
+            try:
+                import torch
+                from dia.model import Dia
+                self.model = Dia.from_pretrained()
+                logger.info("Dia model successfully loaded")
+            except ImportError as e:
+                logger.error(f"Failed to import Dia dependencies: {str(e)}")
+                self.model = None
+            except FileNotFoundError as e:
+                logger.error(f"Failed to load Dia model files: {str(e)}")
+                self.model = None
+            except Exception as e:
+                logger.error(f"Failed to initialize Dia model: {str(e)}")
+                self.model = None
+        return self.model is not None
+
+    def is_available(self) -> bool:
+        """Check if Dia TTS is available."""
+        return DIA_AVAILABLE and self._ensure_model()
+
+    def get_available_voices(self) -> list[str]:
+        """Get available voices for Dia."""
+        # Dia typically uses a default voice
+        return ['default']
+
+    def _generate_audio(self, request: 'SpeechSynthesisRequest') -> tuple[bytes, int]:
+        """Generate audio using Dia TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("Dia TTS engine is not available")
+
+        try:
+            import torch
+            
+            # Extract parameters from request
+            text = request.text_content.text
+
+            # Generate audio using Dia
+            with torch.inference_mode():
+                output_audio_np = self.model.generate(
+                    text,
+                    max_tokens=None,
+                    cfg_scale=3.0,
+                    temperature=1.3,
+                    top_p=0.95,
+                    cfg_filter_top_k=35,
+                    use_torch_compile=False,
+                    verbose=False
+                )
+
+            if output_audio_np is None:
+                raise SpeechSynthesisException("Dia model returned None for audio output")
+
+            # Convert numpy array to bytes
+            audio_bytes = self._numpy_to_bytes(output_audio_np, sample_rate=DEFAULT_SAMPLE_RATE)
+            return audio_bytes, DEFAULT_SAMPLE_RATE
+
+        except ModuleNotFoundError as e:
+            if "dac" in str(e):
+                raise SpeechSynthesisException("Dia TTS engine failed due to missing 'dac' module") from e
+            else:
+                self._handle_provider_error(e, "audio generation")
+        except Exception as e:
+            self._handle_provider_error(e, "audio generation")
+
+    def _generate_audio_stream(self, request: 'SpeechSynthesisRequest') -> Iterator[tuple[bytes, int, bool]]:
+        """Generate audio stream using Dia TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("Dia TTS engine is not available")
+
+        try:
+            import torch
+            
+            # Extract parameters from request
+            text = request.text_content.text
+
+            # Generate audio using Dia
+            with torch.inference_mode():
+                output_audio_np = self.model.generate(
+                    text,
+                    max_tokens=None,
+                    cfg_scale=3.0,
+                    temperature=1.3,
+                    top_p=0.95,
+                    cfg_filter_top_k=35,
+                    use_torch_compile=False,
+                    verbose=False
+                )
+
+            if output_audio_np is None:
+                raise SpeechSynthesisException("Dia model returned None for audio output")
+
+            # Convert numpy array to bytes
+            audio_bytes = self._numpy_to_bytes(output_audio_np, sample_rate=DEFAULT_SAMPLE_RATE)
+            # Dia generates complete audio in one go
+            yield audio_bytes, DEFAULT_SAMPLE_RATE, True
+
+        except ModuleNotFoundError as e:
+            if "dac" in str(e):
+                raise SpeechSynthesisException("Dia TTS engine failed due to missing 'dac' module") from e
+            else:
+                self._handle_provider_error(e, "streaming audio generation")
+        except Exception as e:
+            self._handle_provider_error(e, "streaming audio generation")
+
+    def _numpy_to_bytes(self, audio_array: np.ndarray, sample_rate: int) -> bytes:
+        """Convert numpy audio array to bytes."""
+        try:
+            # Create an in-memory buffer
+            buffer = io.BytesIO()
+            
+            # Write audio data to buffer as WAV
+            sf.write(buffer, audio_array, sample_rate, format='WAV')
+            
+            # Get bytes from buffer
+            buffer.seek(0)
+            return buffer.read()
+            
+        except Exception as e:
+            raise SpeechSynthesisException(f"Failed to convert audio to bytes: {str(e)}") from e

src/infrastructure/tts/dummy_provider.py

@@ -0,0 +1,139 @@
+"""Dummy TTS provider implementation for testing and fallback."""
+
+import logging
+import numpy as np
+import soundfile as sf
+import io
+from typing import Iterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...domain.models.speech_synthesis_request import SpeechSynthesisRequest
+
+from ..base.tts_provider_base import TTSProviderBase
+from ...domain.exceptions import SpeechSynthesisException
+
+logger = logging.getLogger(__name__)
+
+
+class DummyTTSProvider(TTSProviderBase):
+    """Dummy TTS provider that generates sine wave audio for testing."""
+
+    def __init__(self):
+        """Initialize the Dummy TTS provider."""
+        super().__init__(
+            provider_name="Dummy",
+            supported_languages=['en', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh']
+        )
+
+    def is_available(self) -> bool:
+        """Dummy TTS is always available."""
+        return True
+
+    def get_available_voices(self) -> list[str]:
+        """Get available voices for Dummy TTS."""
+        return ['default', 'male', 'female', 'robot']
+
+    def _generate_audio(self, request: 'SpeechSynthesisRequest') -> tuple[bytes, int]:
+        """Generate dummy sine wave audio."""
+        try:
+            # Extract parameters from request
+            text = request.text_content.text
+            speed = request.voice_settings.speed
+
+            # Generate a simple sine wave based on text length and speed
+            sample_rate = 24000
+            # Rough approximation of speech duration adjusted by speed
+            duration = min(len(text) / (20 * speed), 10)
+            
+            # Create time array
+            t = np.linspace(0, duration, int(sample_rate * duration), endpoint=False)
+            
+            # Generate sine wave (440 Hz base frequency)
+            frequency = 440
+            audio = 0.5 * np.sin(2 * np.pi * frequency * t)
+            
+            # Add some variation based on voice setting
+            voice = request.voice_settings.voice_id
+            if voice == 'male':
+                # Lower frequency for male voice
+                audio = 0.5 * np.sin(2 * np.pi * 220 * t)
+            elif voice == 'female':
+                # Higher frequency for female voice
+                audio = 0.5 * np.sin(2 * np.pi * 660 * t)
+            elif voice == 'robot':
+                # Square wave for robot voice
+                audio = 0.5 * np.sign(np.sin(2 * np.pi * 440 * t))
+
+            # Convert to bytes
+            audio_bytes = self._numpy_to_bytes(audio, sample_rate)
+            
+            logger.info(f"Generated dummy audio: duration={duration:.2f}s, voice={voice}")
+            return audio_bytes, sample_rate
+
+        except Exception as e:
+            self._handle_provider_error(e, "dummy audio generation")
+
+    def _generate_audio_stream(self, request: 'SpeechSynthesisRequest') -> Iterator[tuple[bytes, int, bool]]:
+        """Generate dummy sine wave audio stream."""
+        try:
+            # Extract parameters from request
+            text = request.text_content.text
+            speed = request.voice_settings.speed
+
+            # Generate audio in chunks
+            sample_rate = 24000
+            chunk_duration = 1.0  # 1 second chunks
+            total_duration = min(len(text) / (20 * speed), 10)
+            
+            chunks_count = int(np.ceil(total_duration / chunk_duration))
+            
+            for chunk_idx in range(chunks_count):
+                start_time = chunk_idx * chunk_duration
+                end_time = min((chunk_idx + 1) * chunk_duration, total_duration)
+                actual_duration = end_time - start_time
+                
+                if actual_duration <= 0:
+                    break
+                
+                # Create time array for this chunk
+                t = np.linspace(0, actual_duration, int(sample_rate * actual_duration), endpoint=False)
+                
+                # Generate sine wave
+                frequency = 440
+                audio = 0.5 * np.sin(2 * np.pi * frequency * t)
+                
+                # Apply voice variations
+                voice = request.voice_settings.voice_id
+                if voice == 'male':
+                    audio = 0.5 * np.sin(2 * np.pi * 220 * t)
+                elif voice == 'female':
+                    audio = 0.5 * np.sin(2 * np.pi * 660 * t)
+                elif voice == 'robot':
+                    audio = 0.5 * np.sign(np.sin(2 * np.pi * 440 * t))
+
+                # Convert to bytes
+                audio_bytes = self._numpy_to_bytes(audio, sample_rate)
+                
+                # Check if this is the final chunk
+                is_final = (chunk_idx == chunks_count - 1)
+                
+                yield audio_bytes, sample_rate, is_final
+
+        except Exception as e:
+            self._handle_provider_error(e, "dummy streaming audio generation")
+
+    def _numpy_to_bytes(self, audio_array: np.ndarray, sample_rate: int) -> bytes:
+        """Convert numpy audio array to bytes."""
+        try:
+            # Create an in-memory buffer
+            buffer = io.BytesIO()
+            
+            # Write audio data to buffer as WAV
+            sf.write(buffer, audio_array, sample_rate, format='WAV')
+            
+            # Get bytes from buffer
+            buffer.seek(0)
+            return buffer.read()
+            
+        except Exception as e:
+            raise SpeechSynthesisException(f"Failed to convert audio to bytes: {str(e)}") from e

src/infrastructure/tts/kokoro_provider.py

@@ -0,0 +1,131 @@
+"""Kokoro TTS provider implementation."""
+
+import logging
+import numpy as np
+import soundfile as sf
+import io
+from typing import Iterator, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ...domain.models.speech_synthesis_request import SpeechSynthesisRequest
+
+from ..base.tts_provider_base import TTSProviderBase
+from ...domain.exceptions import SpeechSynthesisException
+
+logger = logging.getLogger(__name__)
+
+# Flag to track Kokoro availability
+KOKORO_AVAILABLE = False
+
+# Try to import Kokoro
+try:
+    from kokoro import KPipeline
+    KOKORO_AVAILABLE = True
+    logger.info("Kokoro TTS engine is available")
+except ImportError:
+    logger.warning("Kokoro TTS engine is not available")
+except Exception as e:
+    logger.error(f"Kokoro import failed with unexpected error: {str(e)}")
+    KOKORO_AVAILABLE = False
+
+
+class KokoroTTSProvider(TTSProviderBase):
+    """Kokoro TTS provider implementation."""
+
+    def __init__(self, lang_code: str = 'z'):
+        """Initialize the Kokoro TTS provider."""
+        super().__init__(
+            provider_name="Kokoro",
+            supported_languages=['en', 'z']  # Kokoro supports English and multilingual
+        )
+        self.lang_code = lang_code
+        self.pipeline = None
+
+    def _ensure_pipeline(self):
+        """Ensure the pipeline is loaded."""
+        if self.pipeline is None and KOKORO_AVAILABLE:
+            try:
+                self.pipeline = KPipeline(lang_code=self.lang_code)
+                logger.info("Kokoro pipeline successfully loaded")
+            except Exception as e:
+                logger.error(f"Failed to initialize Kokoro pipeline: {str(e)}")
+                self.pipeline = None
+        return self.pipeline is not None
+
+    def is_available(self) -> bool:
+        """Check if Kokoro TTS is available."""
+        return KOKORO_AVAILABLE and self._ensure_pipeline()
+
+    def get_available_voices(self) -> list[str]:
+        """Get available voices for Kokoro."""
+        # Common Kokoro voices based on the original implementation
+        return [
+            'af_heart', 'af_bella', 'af_sarah', 'af_nicole',
+            'am_adam', 'am_michael', 'bf_emma', 'bf_isabella'
+        ]
+
+    def _generate_audio(self, request: 'SpeechSynthesisRequest') -> tuple[bytes, int]:
+        """Generate audio using Kokoro TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("Kokoro TTS engine is not available")
+
+        try:
+            # Extract parameters from request
+            text = request.text_content.text
+            voice = request.voice_settings.voice_id
+            speed = request.voice_settings.speed
+
+            # Generate speech using Kokoro
+            generator = self.pipeline(text, voice=voice, speed=speed)
+            
+            for _, _, audio in generator:
+                # Convert numpy array to bytes
+                audio_bytes = self._numpy_to_bytes(audio, sample_rate=24000)
+                return audio_bytes, 24000
+
+            raise SpeechSynthesisException("Kokoro failed to generate audio")
+
+        except Exception as e:
+            self._handle_provider_error(e, "audio generation")
+
+    def _generate_audio_stream(self, request: 'SpeechSynthesisRequest') -> Iterator[tuple[bytes, int, bool]]:
+        """Generate audio stream using Kokoro TTS."""
+        if not self.is_available():
+            raise SpeechSynthesisException("Kokoro TTS engine is not available")
+
+        try:
+            # Extract parameters from request
+            text = request.text_content.text
+            voice = request.voice_settings.voice_id
+            speed = request.voice_settings.speed
+
+            # Generate speech stream using Kokoro
+            generator = self.pipeline(text, voice=voice, speed=speed)
+            
+            chunk_count = 0
+            for _, _, audio in generator:
+                chunk_count += 1
+                # Convert numpy array to bytes
+                audio_bytes = self._numpy_to_bytes(audio, sample_rate=24000)
+                # Assume this is the final chunk for now (Kokoro typically generates one chunk)
+                is_final = True
+                yield audio_bytes, 24000, is_final
+
+        except Exception as e:
+            self._handle_provider_error(e, "streaming audio generation")
+
+    def _numpy_to_bytes(self, audio_array: np.ndarray, sample_rate: int) -> bytes:
+        """Convert numpy audio array to bytes."""
+        try:
+            # Create an in-memory buffer
+            buffer = io.BytesIO()
+            
+            # Write audio data to buffer as WAV
+            sf.write(buffer, audio_array, sample_rate, format='WAV')
+            
+            # Get bytes from buffer
+            buffer.seek(0)
+            return buffer.read()
+            
+        except Exception as e:
+            raise SpeechSynthesisException(f"Failed to convert audio to bytes: {str(e)}") from e

src/infrastructure/tts/provider_factory.py

@@ -0,0 +1,204 @@
+"""TTS provider factory for creating and managing TTS providers."""
+
+import logging
+from typing import Dict, List, Optional, Type
+from ..base.tts_provider_base import TTSProviderBase
+from ...domain.exceptions import SpeechSynthesisException
+
+logger = logging.getLogger(__name__)
+
+
+class TTSProviderFactory:
+    """Factory for creating and managing TTS providers."""
+
+    def __init__(self):
+        """Initialize the TTS provider factory."""
+        self._providers: Dict[str, Type[TTSProviderBase]] = {}
+        self._provider_instances: Dict[str, TTSProviderBase] = {}
+        self._register_default_providers()
+
+    def _register_default_providers(self):
+        """Register all available TTS providers."""
+        # Import providers dynamically to avoid import errors if dependencies are missing
+        
+        # Always register dummy provider as fallback
+        from .dummy_provider import DummyTTSProvider
+        self._providers['dummy'] = DummyTTSProvider
+
+        # Try to register Kokoro provider
+        try:
+            from .kokoro_provider import KokoroTTSProvider
+            self._providers['kokoro'] = KokoroTTSProvider
+            logger.info("Registered Kokoro TTS provider")
+        except ImportError as e:
+            logger.debug(f"Kokoro TTS provider not available: {e}")
+
+        # Try to register Dia provider
+        try:
+            from .dia_provider import DiaTTSProvider
+            self._providers['dia'] = DiaTTSProvider
+            logger.info("Registered Dia TTS provider")
+        except ImportError as e:
+            logger.debug(f"Dia TTS provider not available: {e}")
+
+        # Try to register CosyVoice2 provider
+        try:
+            from .cosyvoice2_provider import CosyVoice2TTSProvider
+            self._providers['cosyvoice2'] = CosyVoice2TTSProvider
+            logger.info("Registered CosyVoice2 TTS provider")
+        except ImportError as e:
+            logger.debug(f"CosyVoice2 TTS provider not available: {e}")
+
+    def get_available_providers(self) -> List[str]:
+        """Get list of available TTS providers."""
+        available = []
+        for name, provider_class in self._providers.items():
+            try:
+                # Create instance if not cached
+                if name not in self._provider_instances:
+                    if name == 'kokoro':
+                        self._provider_instances[name] = provider_class()
+                    elif name == 'dia':
+                        self._provider_instances[name] = provider_class()
+                    elif name == 'cosyvoice2':
+                        self._provider_instances[name] = provider_class()
+                    else:
+                        self._provider_instances[name] = provider_class()
+
+                # Check if provider is available
+                if self._provider_instances[name].is_available():
+                    available.append(name)
+                    
+            except Exception as e:
+                logger.warning(f"Failed to check availability of {name} provider: {e}")
+                
+        return available
+
+    def create_provider(self, provider_name: str, **kwargs) -> TTSProviderBase:
+        """
+        Create a TTS provider instance.
+
+        Args:
+            provider_name: Name of the provider to create
+            **kwargs: Additional arguments for provider initialization
+
+        Returns:
+            TTSProviderBase: The created provider instance
+
+        Raises:
+            SpeechSynthesisException: If provider is not available or creation fails
+        """
+        if provider_name not in self._providers:
+            available = list(self._providers.keys())
+            raise SpeechSynthesisException(
+                f"Unknown TTS provider: {provider_name}. Available providers: {available}"
+            )
+
+        try:
+            provider_class = self._providers[provider_name]
+            
+            # Create instance with appropriate parameters
+            if provider_name in ['kokoro', 'dia', 'cosyvoice2']:
+                lang_code = kwargs.get('lang_code', 'z')
+                provider = provider_class(lang_code=lang_code)
+            else:
+                provider = provider_class(**kwargs)
+
+            # Verify the provider is available
+            if not provider.is_available():
+                raise SpeechSynthesisException(f"TTS provider {provider_name} is not available")
+
+            logger.info(f"Created TTS provider: {provider_name}")
+            return provider
+
+        except Exception as e:
+            logger.error(f"Failed to create TTS provider {provider_name}: {e}")
+            raise SpeechSynthesisException(f"Failed to create TTS provider {provider_name}: {e}") from e
+
+    def get_provider_with_fallback(self, preferred_providers: List[str] = None, **kwargs) -> TTSProviderBase:
+        """
+        Get a TTS provider with fallback logic.
+
+        Args:
+            preferred_providers: List of preferred providers in order of preference
+            **kwargs: Additional arguments for provider initialization
+
+        Returns:
+            TTSProviderBase: The first available provider
+
+        Raises:
+            SpeechSynthesisException: If no providers are available
+        """
+        if preferred_providers is None:
+            preferred_providers = ['kokoro', 'dia', 'cosyvoice2', 'dummy']
+
+        available_providers = self.get_available_providers()
+        
+        # Try preferred providers in order
+        for provider_name in preferred_providers:
+            if provider_name in available_providers:
+                try:
+                    return self.create_provider(provider_name, **kwargs)
+                except Exception as e:
+                    logger.warning(f"Failed to create preferred provider {provider_name}: {e}")
+                    continue
+
+        # If no preferred providers work, try any available provider
+        for provider_name in available_providers:
+            if provider_name not in preferred_providers:
+                try:
+                    return self.create_provider(provider_name, **kwargs)
+                except Exception as e:
+                    logger.warning(f"Failed to create fallback provider {provider_name}: {e}")
+                    continue
+
+        raise SpeechSynthesisException("No TTS providers are available")
+
+    def get_provider_info(self, provider_name: str) -> Dict:
+        """
+        Get information about a specific provider.
+
+        Args:
+            provider_name: Name of the provider
+
+        Returns:
+            Dict: Provider information including availability and supported features
+        """
+        if provider_name not in self._providers:
+            return {"available": False, "error": "Provider not registered"}
+
+        try:
+            # Create instance if not cached
+            if provider_name not in self._provider_instances:
+                provider_class = self._providers[provider_name]
+                if provider_name in ['kokoro', 'dia', 'cosyvoice2']:
+                    self._provider_instances[provider_name] = provider_class()
+                else:
+                    self._provider_instances[provider_name] = provider_class()
+
+            provider = self._provider_instances[provider_name]
+            
+            return {
+                "available": provider.is_available(),
+                "name": provider.provider_name,
+                "supported_languages": provider.supported_languages,
+                "available_voices": provider.get_available_voices() if provider.is_available() else []
+            }
+
+        except Exception as e:
+            return {
+                "available": False,
+                "error": str(e)
+            }
+
+    def cleanup_providers(self):
+        """Clean up provider instances and resources."""
+        for provider in self._provider_instances.values():
+            try:
+                if hasattr(provider, '_cleanup_temp_files'):
+                    provider._cleanup_temp_files()
+            except Exception as e:
+                logger.warning(f"Failed to cleanup provider {provider.provider_name}: {e}")
+        
+        self._provider_instances.clear()
+        logger.info("Cleaned up TTS provider instances")

test_tts_migration.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Test script to verify TTS provider migration."""
+
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+def test_provider_imports():
+    """Test that all providers can be imported."""
+    print("Testing provider imports...")
+    
+    try:
+        from src.infrastructure.tts import TTSProviderFactory, DummyTTSProvider
+        print("✓ Core TTS components imported successfully")
+    except Exception as e:
+        print(f"✗ Failed to import core TTS components: {e}")
+        return False
+    
+    try:
+        from src.domain.models.text_content import TextContent
+        from src.domain.models.voice_settings import VoiceSettings
+        from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
+        print("✓ Domain models imported successfully")
+    except Exception as e:
+        print(f"✗ Failed to import domain models: {e}")
+        return False
+    
+    return True
+
+def test_dummy_provider():
+    """Test the dummy provider functionality."""
+    print("\nTesting dummy provider...")
+    
+    try:
+        from src.infrastructure.tts import DummyTTSProvider
+        from src.domain.models.text_content import TextContent
+        from src.domain.models.voice_settings import VoiceSettings
+        from src.domain.models.speech_synthesis_request import SpeechSynthesisRequest
+        
+        # Create provider
+        provider = DummyTTSProvider()
+        print(f"✓ Created dummy provider: {provider.provider_name}")
+        
+        # Check availability
+        if provider.is_available():
+            print("✓ Dummy provider is available")
+        else:
+            print("✗ Dummy provider is not available")
+            return False
+        
+        # Check voices
+        voices = provider.get_available_voices()
+        print(f"✓ Available voices: {voices}")
+        
+        # Create a synthesis request
+        text_content = TextContent(text="Hello, world!", language="en")
+        voice_settings = VoiceSettings(voice_id="default", speed=1.0, language="en")
+        request = SpeechSynthesisRequest(
+            text_content=text_content,
+            voice_settings=voice_settings
+        )
+        print("✓ Created synthesis request")
+        
+        # Test synthesis
+        audio_content = provider.synthesize(request)
+        print(f"✓ Generated audio: {len(audio_content.data)} bytes, {audio_content.duration:.2f}s")
+        
+        return True
+        
+    except Exception as e:
+        print(f"✗ Dummy provider test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_provider_factory():
+    """Test the provider factory."""
+    print("\nTesting provider factory...")
+    
+    try:
+        from src.infrastructure.tts import TTSProviderFactory
+        
+        factory = TTSProviderFactory()
+        print("✓ Created provider factory")
+        
+        available = factory.get_available_providers()
+        print(f"✓ Available providers: {available}")
+        
+        if 'dummy' not in available:
+            print("✗ Dummy provider should always be available")
+            return False
+        
+        # Test creating dummy provider
+        provider = factory.create_provider('dummy')
+        print(f"✓ Created provider via factory: {provider.provider_name}")
+        
+        # Test fallback logic
+        provider = factory.get_provider_with_fallback()
+        print(f"✓ Got provider with fallback: {provider.provider_name}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"✗ Provider factory test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """Run all tests."""
+    print("=== TTS Provider Migration Test ===\n")
+    
+    tests = [
+        test_provider_imports,
+        test_dummy_provider,
+        test_provider_factory
+    ]
+    
+    passed = 0
+    for test in tests:
+        if test():
+            passed += 1
+        print()
+    
+    print(f"=== Results: {passed}/{len(tests)} tests passed ===")
+    
+    if passed == len(tests):
+        print("🎉 All tests passed! TTS provider migration successful.")
+        return 0
+    else:
+        print("❌ Some tests failed. Check the output above.")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())