dv-pipecat-ai 0.0.85.dev850__tar.gz → 0.0.85.dev851__tar.gz

{dv_pipecat_ai-0.0.85.dev850 → dv_pipecat_ai-0.0.85.dev851}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev850
+Version: 0.0.85.dev851
 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.85.dev850 → dv_pipecat_ai-0.0.85.dev851}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev850
+Version: 0.0.85.dev851
 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.85.dev850 → dv_pipecat_ai-0.0.85.dev851}/src/pipecat/services/elevenlabs/stt.py

@@ -159,10 +159,16 @@ def language_to_elevenlabs_language(language: Language) -> Optional[str]:
     result = BASE_LANGUAGES.get(language)
 
     # If not found in base languages, try to find the base language from a variant
+    # For example, Language.EN_US (value "en-US") -> Language("en") -> "eng"
     if not result:
         lang_str = str(language.value)
-        base_code = lang_str.split("-")[0].lower()
-        result = base_code if base_code in BASE_LANGUAGES.values() else None
+        base_code = lang_str.split("-")[0]  # Get "en" from "en-US"
+        try:
+            base_language = Language(base_code)
+            result = BASE_LANGUAGES.get(base_language)
+        except (ValueError, KeyError):
+            # If base language not found in Language enum, return None
+            result = None
 
     return result
 
@@ -425,6 +431,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         self._pending_final_task: Optional[asyncio.Task] = None
         self._timestamp_merge_delay_s = 0.25
         self._ttfb_started = False
+        self._waiting_for_timestamps = False
 
     @property
     def commit_strategy(self) -> str:
@@ -474,7 +481,9 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if isinstance(frame, UserStartedSpeakingFrame):
             if frame.emulated:
                 return
-            self._ttfb_started = False
+            # Start metrics and set flag to True so we can stop them later
+            await self.start_ttfb_metrics()
+            self._ttfb_started = True
             await self.start_processing_metrics()
         elif isinstance(frame, UserStoppedSpeakingFrame):
             if frame.emulated:
@@ -488,18 +497,28 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             yield None
             return
 
-        await self._ensure_connection()
+        if not await self._ensure_connection():
+            self.logger.error(f"{self} failed to establish connection, dropping audio")
+            yield None
+            return
+
         await self._send_audio_chunk(audio)
         yield None
 
-    async def _ensure_connection(self):
+    async def _ensure_connection(self) -> bool:
+        """Ensure WebSocket connection is established and ready.
+
+        Returns:
+            bool: True if connection is ready, False otherwise.
+        """
         if not self._websocket or self._websocket.state is State.CLOSED:
             await self._connect()
+        return self._websocket is not None and self._websocket.state is State.OPEN
 
     async def _connect(self):
         await self._connect_websocket()
-        if self._websocket and not self._receive_task:
-            self._receive_task = asyncio.create_task(self._receive_task_handler(self._report_error))
+        if self._websocket and self._websocket.state is State.OPEN and not self._receive_task:
+            self._receive_task = self.create_task(self._receive_task_handler(self._report_error))
 
     async def _disconnect(self):
         if self._receive_task:
@@ -512,23 +531,30 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
     async def _connect_websocket(self):
         try:
             if self._websocket and self._websocket.state is State.OPEN:
+                self.logger.debug(f"{self} already connected, skipping reconnection")
                 return
 
             ws_url = self._build_websocket_url()
             headers = {"xi-api-key": self._api_key}
-            self.logger.debug(f"Connecting to ElevenLabs realtime STT at {ws_url}")
+            self.logger.info(f"{self} connecting to ElevenLabs realtime STT (WebSocket URL built)")
             self._websocket = await websocket_connect(ws_url, additional_headers=headers)
+            self.logger.info(f"{self} successfully connected to ElevenLabs realtime STT")
             await self._call_event_handler("on_connected")
         except Exception as e:
             self.logger.error(f"{self} unable to connect to ElevenLabs realtime STT: {e}")
             self._websocket = None
+            if self._receive_task:
+                await self.cancel_task(self._receive_task)
+                self._receive_task = None
+            # Push error to pipeline so callers know the connection failed
+            await self.push_error(ErrorFrame(f"ElevenLabs connection failed: {e}", fatal=False))
             await self._call_event_handler("on_connection_error", f"{e}")
 
     async def _disconnect_websocket(self):
         try:
             await self.stop_all_metrics()
             if self._websocket and self._websocket.state is State.OPEN:
-                self.logger.debug("Disconnecting from ElevenLabs realtime STT")
+                self.logger.debug(f"{self} disconnecting from ElevenLabs realtime STT")
                 await self._websocket.close()
         except Exception as e:
             self.logger.error(f"{self} error closing ElevenLabs realtime websocket: {e}")
@@ -573,6 +599,10 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         }:
             fatal = message_type in {"auth_error", "quota_exceeded", "error"}
             description = data.get("error", data)
+            # Log full error details for debugging
+            self.logger.error(
+                f"{self} ElevenLabs error - Type: {message_type}, Fatal: {fatal}, Full data: {data}"
+            )
             await self.push_error(
                 ErrorFrame(f"ElevenLabs realtime error: {description}", fatal=fatal)
             )
@@ -588,7 +618,11 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             elevenlabs_language_code_to_language(data.get("language_code"))
             or self._language_override
         )
-        await self.stop_ttfb_metrics()
+
+        # Only stop TTFB metrics on first partial
+        if self._ttfb_started:
+            await self.stop_ttfb_metrics()
+            self._ttfb_started = False
 
         await self.push_frame(
             InterimTranscriptionFrame(
@@ -604,8 +638,10 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if self._pending_final_message:
             await self._emit_transcription(self._pending_final_message)
             self._pending_final_message = None
+            self._waiting_for_timestamps = False
 
         self._pending_final_message = data
+        self._waiting_for_timestamps = True
         await self._schedule_pending_final_emit()
 
     async def _handle_committed_transcript_with_timestamps(self, data: Dict[str, Any]):
@@ -613,12 +649,16 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             merged = {**self._pending_final_message, **data}
             await self._emit_transcription(merged)
             await self._clear_pending_final()
+        elif self._waiting_for_timestamps:
+            # Late arrival after timeout - don't emit duplicate
+            self.logger.warning(f"{self} timestamps arrived after timeout, skipping duplicate")
+            self._waiting_for_timestamps = False
         else:
             await self._emit_transcription(data)
 
     async def _schedule_pending_final_emit(self):
         await self._clear_pending_final(timer_only=True)
-        self._pending_final_task = asyncio.create_task(self._emit_pending_after_delay())
+        self._pending_final_task = self.create_task(self._emit_pending_after_delay())
 
     async def _emit_pending_after_delay(self):
         try:
@@ -626,6 +666,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             if self._pending_final_message:
                 await self._emit_transcription(self._pending_final_message)
                 self._pending_final_message = None
+                self._waiting_for_timestamps = False
         except asyncio.CancelledError:
             pass
         finally:
@@ -638,6 +679,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
 
         if not timer_only:
             self._pending_final_message = None
+            self._waiting_for_timestamps = False
 
     async def _emit_transcription(self, data: Dict[str, Any]):
         text = (data.get("text") or data.get("transcript") or "").strip()
@@ -648,7 +690,11 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             elevenlabs_language_code_to_language(data.get("language_code"))
             or self._language_override
         )
-        await self.stop_ttfb_metrics()
+
+        # TTFB should already be stopped by partial, but guard just in case
+        if self._ttfb_started:
+            await self.stop_ttfb_metrics()
+            self._ttfb_started = False
 
         frame = TranscriptionFrame(
             text,
@@ -666,28 +712,39 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if not audio or not self._websocket:
             return
 
-        if not self._ttfb_started:
-            await self.start_ttfb_metrics()
-            self._ttfb_started = True
-
-        payload = {
-            "message_type": "input_audio_chunk",
-            "audio_base_64": base64.b64encode(audio).decode("ascii"),
-            "commit": False,
-            "sample_rate": self.sample_rate,
-        }
-        await self._websocket.send(json.dumps(payload))
+        try:
+            payload = {
+                "message_type": "input_audio_chunk",
+                "audio_base_64": base64.b64encode(audio).decode("ascii"),
+                "commit": False,
+                "sample_rate": self.sample_rate,
+            }
+            await self._websocket.send(json.dumps(payload))
+        except Exception as e:
+            self.logger.error(f"{self} error sending audio chunk: {e}")
+            await self.push_error(ErrorFrame(f"Failed to send audio: {e}"))
+            # Trigger reconnection
+            await self._disconnect()
+            await self._connect()
 
     async def _send_commit(self):
         if not self._websocket:
             return
-        payload = {
-            "message_type": "input_audio_chunk",
-            "audio_base_64": "",
-            "commit": True,
-            "sample_rate": self.sample_rate,
-        }
-        await self._websocket.send(json.dumps(payload))
+
+        try:
+            payload = {
+                "message_type": "input_audio_chunk",
+                "audio_base_64": "",
+                "commit": True,
+                "sample_rate": self.sample_rate,
+            }
+            await self._websocket.send(json.dumps(payload))
+        except Exception as e:
+            self.logger.error(f"{self} error sending commit: {e}")
+            await self.push_error(ErrorFrame(f"Failed to send commit: {e}"))
+            # Trigger reconnection
+            await self._disconnect()
+            await self._connect()
 
     def _build_websocket_url(self) -> str:
         if not self.sample_rate: