dv-pipecat-ai 0.0.93.dev135__tar.gz → 0.0.93.dev136__tar.gz

{dv_pipecat_ai-0.0.93.dev135/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev136}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev135
+Version: 0.0.93.dev136
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.93.dev135 → dv_pipecat_ai-0.0.93.dev136/src/dv_pipecat_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev135
+Version: 0.0.93.dev136
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

dv_pipecat_ai-0.0.93.dev136/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.0.92",
+  "distance": 136,
+  "node": "gc5eead3484ac34c95382dd840f21fea051699b29",
+  "dirty": false,
+  "branch": "dv-stage",
+  "node_date": "2026-08-31"
+}

{dv_pipecat_ai-0.0.93.dev135 → dv_pipecat_ai-0.0.93.dev136}/src/pipecat/services/google/tts.py

@@ -11,7 +11,8 @@ offering both HTTP-based synthesis with SSML support and streaming synthesis
 for real-time applications.
 
 It also includes GeminiTTSService which uses Gemini's TTS-specific models
-for natural voice control and multi-speaker conversations.
+(e.g. gemini-2.5-flash-tts) over the Cloud TTS streaming API for natural
+voice control with low-latency synthesis.
 """
 
 import json
@@ -30,7 +31,6 @@ from pydantic import BaseModel
 from pipecat.frames.frames import (
     ErrorFrame,
     Frame,
-    StartFrame,
     TTSAudioRawFrame,
     TTSStartedFrame,
     TTSStoppedFrame,
@@ -51,16 +51,6 @@ except ModuleNotFoundError as e:
     )
     raise Exception(f"Missing module: {e}")
 
-try:
-    from google import genai
-    from google.genai import types
-
-except ModuleNotFoundError as e:
-    logger.error(f"Exception: {e}")
-    logger.error("In order to use Gemini TTS, you need to `pip install pipecat-ai[google]`.")
-    raise Exception(f"Missing module: {e}")
-
-
 def language_to_google_tts_language(language: Language) -> Optional[str]:
     """Convert a Language enum to Google TTS language code.
 
@@ -681,63 +671,91 @@ class GoogleTTSService(TTSService):
             yield ErrorFrame(error=error_message)
 
 
+def language_to_gemini_tts_language(language: Language) -> Optional[str]:
+    """Convert a Language enum to a Gemini-TTS language code.
+
+    Gemini-TTS locales mostly match Cloud TTS ones, but a few differ
+    (https://cloud.google.com/text-to-speech/docs/gemini-tts#available_languages):
+    Arabic is served as ``ar-EG`` (Cloud TTS uses the pan-Arabic ``ar-XA``,
+    which Gemini-TTS rejects) and Urdu as ``ur-PK``. Everything else falls
+    back to the Cloud TTS mapping.
+
+    Args:
+        language: The Language enum value to convert.
+
+    Returns:
+        The corresponding Gemini-TTS language code, or None if not supported.
+    """
+    overrides = {
+        Language.AR: "ar-EG",
+        Language.UR: "ur-PK",
+    }
+    if language in overrides:
+        return overrides[language]
+    return language_to_google_tts_language(language)
+
+
 class GeminiTTSService(TTSService):
-    """Gemini Text-to-Speech service using Gemini TTS models.
+    """Gemini Text-to-Speech streaming service using Gemini TTS models.
 
-    Provides text-to-speech synthesis using Gemini's TTS-specific models
-    (gemini-2.5-flash-preview-tts and gemini-2.5-pro-preview-tts) with
-    support for natural voice control, multiple speakers, and voice styles.
+    Provides real-time text-to-speech synthesis using Gemini's TTS-specific
+    models (e.g. "gemini-2.5-flash-tts", "gemini-2.5-pro-tts") through the
+    Google Cloud Text-to-Speech streaming API for low-latency synthesis, with
+    support for style instruction prompts.
 
     Note:
-        Requires Google AI API key. This uses the Gemini API, not Google Cloud TTS.
-        Audio-out is currently a preview feature.
+        Requires Google Cloud credentials via service account JSON, file path,
+        or default application credentials (GOOGLE_APPLICATION_CREDENTIALS /
+        Workload Identity). This uses the Cloud TTS API, not the Gemini API,
+        so no Gemini API key is needed.
 
     Example::
 
         tts = GeminiTTSService(
-            api_key="your-google-ai-api-key",
-            model="gemini-2.5-flash-preview-tts",
-            voice_id="Kore",
+            credentials_path="/path/to/service-account.json",
+            model="gemini-2.5-flash-tts",
+            voice_id="Achernar",
             params=GeminiTTSService.InputParams(
-                language=Language.EN_US,
+                language=Language.HI,
+                prompt="Speak in a friendly and helpful tone",
             )
         )
     """
 
-    GOOGLE_SAMPLE_RATE = 24000  # Google TTS always outputs at 24kHz
+    GOOGLE_SAMPLE_RATE = 24000  # Native Gemini TTS output rate
 
     # List of available Gemini TTS voices
     AVAILABLE_VOICES = [
-        "Zephyr",
-        "Puck",
-        "Charon",
-        "Kore",
-        "Fenrir",
-        "Leda",
-        "Orus",
+        "Achernar",
+        "Achird",
+        "Algenib",
+        "Algieba",
+        "Alnilam",
         "Aoede",
-        "Callirhoe",
         "Autonoe",
-        "Enceladus",
-        "Iapetus",
-        "Umbriel",
-        "Algieba",
+        "Callirrhoe",
+        "Charon",
         "Despina",
+        "Enceladus",
         "Erinome",
-        "Algenib",
-        "Rasalgethi",
-        "Laomedeia",
-        "Achernar",
-        "Alnilam",
-        "Schedar",
+        "Fenrir",
         "Gacrux",
+        "Iapetus",
+        "Kore",
+        "Laomedeia",
+        "Leda",
+        "Orus",
+        "Puck",
         "Pulcherrima",
-        "Achird",
-        "Zubenelgenubi",
-        "Vindemiatrix",
+        "Rasalgethi",
         "Sadachbia",
         "Sadaltager",
-        "Sulafar",
+        "Schedar",
+        "Sulafat",
+        "Umbriel",
+        "Vindemiatrix",
+        "Zephyr",
+        "Zubenelgenubi",
     ]
 
     class InputParams(BaseModel):
@@ -745,19 +763,19 @@ class GeminiTTSService(TTSService):
 
         Parameters:
             language: Language for synthesis. Defaults to English.
-            multi_speaker: Whether to enable multi-speaker support.
-            speaker_configs: List of speaker configurations for multi-speaker mode.
+            prompt: Optional style instructions for how to synthesize the
+                content (e.g. "Say this in a friendly tone").
         """
 
         language: Optional[Language] = Language.EN
-        multi_speaker: bool = False
-        speaker_configs: Optional[List[dict]] = None
+        prompt: Optional[str] = None
 
     def __init__(
         self,
         *,
-        api_key: str,
-        model: str = "gemini-2.5-flash-preview-tts",
+        credentials: Optional[str] = None,
+        credentials_path: Optional[str] = None,
+        model: str = "gemini-2.5-flash-tts",
         voice_id: str = "Kore",
         sample_rate: Optional[int] = None,
         params: Optional[InputParams] = None,
@@ -766,19 +784,16 @@ class GeminiTTSService(TTSService):
         """Initializes the Gemini TTS service.
 
         Args:
-            api_key: Google AI API key for authentication.
-            model: Gemini TTS model to use. Must be a TTS model like
-                   "gemini-2.5-flash-preview-tts" or "gemini-2.5-pro-preview-tts".
+            credentials: JSON string containing Google Cloud service account credentials.
+            credentials_path: Path to Google Cloud service account JSON file.
+            model: Gemini TTS model to use, e.g. "gemini-2.5-flash-tts" or
+                   "gemini-2.5-pro-tts".
             voice_id: Voice name from the available Gemini voices.
-            sample_rate: Audio sample rate in Hz. If None, uses Google's default 24kHz.
+            sample_rate: Audio sample rate in Hz. If None, uses the pipeline default;
+                         the Cloud TTS API resamples server-side.
             params: TTS configuration parameters.
             **kwargs: Additional arguments passed to parent TTSService.
         """
-        if sample_rate and sample_rate != self.GOOGLE_SAMPLE_RATE:
-            logger.warning(
-                f"Google TTS only supports {self.GOOGLE_SAMPLE_RATE}Hz sample rate. "
-                f"Current rate of {sample_rate}Hz may cause issues."
-            )
         super().__init__(sample_rate=sample_rate, **kwargs)
 
         params = params or GeminiTTSService.InputParams()
@@ -786,18 +801,42 @@ class GeminiTTSService(TTSService):
         if voice_id not in self.AVAILABLE_VOICES:
             logger.warning(f"Voice '{voice_id}' not in known voices list. Using anyway.")
 
-        self._api_key = api_key
         self._model = model
-        self._voice_id = voice_id
+        self.set_voice(voice_id)
         self._settings = {
             "language": self.language_to_service_language(params.language)
             if params.language
             else "en-US",
-            "multi_speaker": params.multi_speaker,
-            "speaker_configs": params.speaker_configs,
+            "prompt": params.prompt,
         }
+        self._client: texttospeech_v1.TextToSpeechAsyncClient = self._create_client(
+            credentials, credentials_path
+        )
 
-        self._client = genai.Client(api_key=api_key)
+    def _create_client(
+        self, credentials: Optional[str], credentials_path: Optional[str]
+    ) -> texttospeech_v1.TextToSpeechAsyncClient:
+        creds: Optional[service_account.Credentials] = None
+
+        if credentials:
+            # Use provided credentials JSON string
+            json_account_info = json.loads(credentials)
+            creds = service_account.Credentials.from_service_account_info(json_account_info)
+        elif credentials_path:
+            # Use service account JSON file if provided
+            creds = service_account.Credentials.from_service_account_file(credentials_path)
+        else:
+            try:
+                creds, project_id = default(
+                    scopes=["https://www.googleapis.com/auth/cloud-platform"]
+                )
+            except GoogleAuthError:
+                pass
+
+        if not creds:
+            raise ValueError("No valid credentials provided.")
+
+        return texttospeech_v1.TextToSpeechAsyncClient(credentials=creds)
 
     def can_generate_metrics(self) -> bool:
         """Check if this service can generate processing metrics.
@@ -816,111 +855,76 @@ class GeminiTTSService(TTSService):
         Returns:
             The Gemini TTS-specific language code, or None if not supported.
         """
-        return language_to_google_tts_language(language)
-
-    def set_voice(self, voice_id: str):
-        """Set the voice for TTS generation.
-
-        Args:
-            voice_id: Name of the voice to use from AVAILABLE_VOICES.
-        """
-        if voice_id not in self.AVAILABLE_VOICES:
-            logger.warning(f"Voice '{voice_id}' not in known voices list. Using anyway.")
-        self._voice_id = voice_id
-
-    async def start(self, frame: StartFrame):
-        """Start the Gemini TTS service.
-
-        Args:
-            frame: The start frame containing initialization parameters.
-        """
-        await super().start(frame)
-        if self.sample_rate != self.GOOGLE_SAMPLE_RATE:
-            logger.warning(
-                f"Google TTS requires {self.GOOGLE_SAMPLE_RATE}Hz sample rate. "
-                f"Current rate of {self.sample_rate}Hz may cause issues."
-            )
+        return language_to_gemini_tts_language(language)
 
     @traced_tts
     async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
-        """Generate speech from text using Gemini TTS models.
+        """Generate streaming speech from text using Gemini TTS models.
 
         Args:
-            text: The text to synthesize into speech. Can include natural language
-                  instructions for style, tone, etc.
+            text: The text to synthesize into speech.
 
         Yields:
-            Frame: Audio frames containing the synthesized speech.
+            Frame: Audio frames containing the synthesized speech as it's generated.
         """
         logger.debug(f"{self}: Generating TTS [{text}]")
 
         try:
             await self.start_ttfb_metrics()
 
-            # Build the speech config
-            if self._settings["multi_speaker"] and self._settings["speaker_configs"]:
-                # Multi-speaker mode
-                speaker_voice_configs = []
-                for speaker_config in self._settings["speaker_configs"]:
-                    speaker_voice_configs.append(
-                        types.SpeakerVoiceConfig(
-                            speaker=speaker_config["speaker"],
-                            voice_config=types.VoiceConfig(
-                                prebuilt_voice_config=types.PrebuiltVoiceConfig(
-                                    voice_name=speaker_config.get("voice_id", self._voice_id)
-                                )
-                            ),
-                        )
-                    )
-
-                speech_config = types.SpeechConfig(
-                    multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
-                        speaker_voice_configs=speaker_voice_configs
-                    )
-                )
-            else:
-                # Single speaker mode
-                speech_config = types.SpeechConfig(
-                    voice_config=types.VoiceConfig(
-                        prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=self._voice_id)
-                    )
-                )
-
-            # Create the generation config
-            generation_config = types.GenerateContentConfig(
-                response_modalities=["AUDIO"],
-                speech_config=speech_config,
+            voice = texttospeech_v1.VoiceSelectionParams(
+                language_code=self._settings["language"],
+                name=self._voice_id,
+                model_name=self._model,
             )
 
-            # Generate the content
-            response = await self._client.aio.models.generate_content(
-                model=self._model,
-                contents=text,
-                config=generation_config,
+            streaming_config = texttospeech_v1.StreamingSynthesizeConfig(
+                voice=voice,
+                streaming_audio_config=texttospeech_v1.StreamingAudioConfig(
+                    audio_encoding=texttospeech_v1.AudioEncoding.PCM,
+                    sample_rate_hertz=self.sample_rate,
+                ),
+            )
+            config_request = texttospeech_v1.StreamingSynthesizeRequest(
+                streaming_config=streaming_config
             )
 
+            async def request_generator():
+                yield config_request
+                input_kwargs = {"text": text}
+                if self._settings["prompt"]:
+                    input_kwargs["prompt"] = self._settings["prompt"]
+                yield texttospeech_v1.StreamingSynthesizeRequest(
+                    input=texttospeech_v1.StreamingSynthesisInput(**input_kwargs)
+                )
+
+            streaming_responses = await self._client.streaming_synthesize(request_generator())
             await self.start_tts_usage_metrics(text)
 
             yield TTSStartedFrame()
 
-            # Extract audio data from response
-            if response.candidates and len(response.candidates) > 0:
-                candidate = response.candidates[0]
-                if candidate.content and candidate.content.parts:
-                    for part in candidate.content.parts:
-                        if part.inline_data and part.inline_data.mime_type.startswith("audio/"):
-                            audio_data = part.inline_data.data
-                            await self.stop_ttfb_metrics()
-
-                            # Gemini TTS returns PCM audio data, chunk it appropriately
-                            CHUNK_SIZE = self.chunk_size
-
-                            for i in range(0, len(audio_data), CHUNK_SIZE):
-                                chunk = audio_data[i : i + CHUNK_SIZE]
-                                if not chunk:
-                                    break
-                                frame = TTSAudioRawFrame(chunk, self.sample_rate, 1)
-                                yield frame
+            audio_buffer = b""
+            first_chunk_for_ttfb = False
+
+            CHUNK_SIZE = self.chunk_size
+
+            async for response in streaming_responses:
+                chunk = response.audio_content
+                if not chunk:
+                    continue
+
+                if not first_chunk_for_ttfb:
+                    await self.stop_ttfb_metrics()
+                    first_chunk_for_ttfb = True
+
+                audio_buffer += chunk
+                while len(audio_buffer) >= CHUNK_SIZE:
+                    piece = audio_buffer[:CHUNK_SIZE]
+                    audio_buffer = audio_buffer[CHUNK_SIZE:]
+                    yield TTSAudioRawFrame(piece, self.sample_rate, 1)
+
+            if audio_buffer:
+                yield TTSAudioRawFrame(audio_buffer, self.sample_rate, 1)
 
             yield TTSStoppedFrame()
 

dv_pipecat_ai-0.0.93.dev135/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.0.92",
-  "distance": 135,
-  "node": "ga40d7ed5632375656990a0f78126430855ddac0c",
-  "dirty": false,
-  "branch": "dv-stage",
-  "node_date": "2026-08-26"
-}