dv-pipecat-ai 0.0.85.dev854__py3-none-any.whl → 0.0.85.dev857__py3-none-any.whl

{dv_pipecat_ai-0.0.85.dev854.dist-info → dv_pipecat_ai-0.0.85.dev857.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev854
+Version: 0.0.85.dev857
 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.dev854.dist-info → dv_pipecat_ai-0.0.85.dev857.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dv_pipecat_ai-0.0.85.dev854.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
+dv_pipecat_ai-0.0.85.dev857.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
 pipecat/__init__.py,sha256=j0Xm6adxHhd7D06dIyyPV_GlBYLlBnTAERVvD_jAARQ,861
 pipecat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -82,6 +82,7 @@ pipecat/frames/frames.proto,sha256=JXZm3VXLR8zMOUcOuhVoe2mhM3MQIQGMJXLopdJO_5Y,8
 pipecat/frames/frames.py,sha256=248d54lNOyO04dq9ni51yUTWUItmGw8b9QKarrDGNeo,50354
 pipecat/frames/protobufs/frames_pb2.py,sha256=VHgGV_W7qQ4sfQK6RHb5_DggLm3PiSYMr6aBZ8_p1cQ,2590
 pipecat/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pipecat/metrics/connection_metrics.py,sha256=8rBsEeufL3meWyJHcUbe35TS963W9B0wSnz0dQkv12A,1734
 pipecat/metrics/metrics.py,sha256=bdZNciEtLTtA-xgoKDz2RJAy6fKrXkTwz3pryVHzc2M,2713
 pipecat/observers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/observers/base_observer.py,sha256=z812gu9lrxtZlr_6oZhcH0NHqlV2cJ7k_B8UJRrm8TY,3459
@@ -108,7 +109,7 @@ pipecat/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 pipecat/processors/async_generator.py,sha256=qPOZxk5eOad_NrF_Z06vWZ6deXIxb9AKZKYO2e5pkJs,2385
 pipecat/processors/consumer_processor.py,sha256=DrWCKnfblknZJ0bLmR_unIeJ1axQw4IPUn2IB3KLGGA,3228
 pipecat/processors/dtmf_aggregator.py,sha256=k3xYncUr_8y5lrYfeX8PxqlF7jqFLshg_HB6HiFg7TA,10193
-pipecat/processors/frame_processor.py,sha256=uBu6Waa0_diMXdQXMZ5V5a_KwaaPzcieyuv5gO9u-ME,33841
+pipecat/processors/frame_processor.py,sha256=rf35H2qnREj0aeOAjXSy5YWTOoLwyzhRfw74J9LTCGg,35588
 pipecat/processors/idle_frame_processor.py,sha256=z8AuhGap61lA5K35P6XCaOpn4kkmK_9NZNppbpQxheU,3124
 pipecat/processors/logger.py,sha256=8xa4KKekXQIETlQR7zoGnwUpLNo8CeDVm7YjyXePN-w,2385
 pipecat/processors/producer_processor.py,sha256=iIIOHZd77APvUGP7JqFbznAHUnCULcq_qYiSEjwXHcc,3265
@@ -145,7 +146,7 @@ pipecat/processors/frameworks/strands_agents.py,sha256=vaYcNtM084OWoXDQaT6eoGoP1
 pipecat/processors/gstreamer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/processors/gstreamer/pipeline_source.py,sha256=eXckOY1rQeSBjSfLs8EFEkdlTZEq94osOTFWeNh6C4Y,9765
 pipecat/processors/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pipecat/processors/metrics/frame_processor_metrics.py,sha256=8X0qRbYqfr8YJoIjp5RKqDxHf8Vlt4OCWcIW9SYaiZo,6665
+pipecat/processors/metrics/frame_processor_metrics.py,sha256=-p1mv6U3w36JWScz4hTsKsRQtUqTZut-kDLqZr6h2x4,10244
 pipecat/processors/metrics/sentry.py,sha256=Gts-b-H3EDFUvv-qn44e9pSDAWUKk72tr7tEfutxxK0,4911
 pipecat/runner/__init__.py,sha256=iJh4vFMGNQYi_ATVGXJDU4rOJwI-1Y6fmkyV18-ddAE,64
 pipecat/runner/daily.py,sha256=t-D-sgVC2SnT_YCTDaQJgcxVnzL8-pQhdmxp7gV2snI,9646
@@ -210,15 +211,15 @@ pipecat/services/cartesia/tts.py,sha256=I_OZCINywkDXmYzFL35MjSN8cAuNEaJs7nj0YB_o
 pipecat/services/cerebras/__init__.py,sha256=5zBmqq9Zfcl-HC7ylekVS5qrRedbl1mAeEwUT-T-c_o,259
 pipecat/services/cerebras/llm.py,sha256=-yzSe_6YDGigwzES-LZS4vNXMPugmvsIYEpTySyr5nA,3047
 pipecat/services/deepgram/__init__.py,sha256=IjRtMI7WytRDdmYVpk2qDWClXUiNgdl7ZkvEAWg1eYE,304
-pipecat/services/deepgram/stt.py,sha256=t7P0zWLBitSF_KQqHr5aYjKdJZRnC36styl_eL86R88,24752
+pipecat/services/deepgram/stt.py,sha256=jej9sFI5xwuC_NwRPjql48sjaOMwOV9B836T67gG70A,25343
 pipecat/services/deepgram/tts.py,sha256=H_2WCJEx3_L4ytrHHRNkA-6GKTd1coou_vvTfiEodpQ,3745
 pipecat/services/deepgram/flux/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/services/deepgram/flux/stt.py,sha256=yCZodrHAOShgYy_GbdviX8iAuh36dBgDL41gHMXVxEM,25887
 pipecat/services/deepseek/__init__.py,sha256=bU5z_oNGzgrF_YpsD9pYIMtEibeZFaUobbRjJ9WcYyE,259
 pipecat/services/deepseek/llm.py,sha256=5KjpU2blmhUTM3LcRE1ymdsk6OmoFkIzeQgyNOGwQh8,3112
 pipecat/services/elevenlabs/__init__.py,sha256=cMx5v0HEMh4WetMm5byR9tIjG6_wNVs9UxqWyB3tjlM,313
-pipecat/services/elevenlabs/stt.py,sha256=dy88MvQdhUQ-SFA7YTBRykZsIozMnnYQaJ4og1RYlVc,30811
-pipecat/services/elevenlabs/tts.py,sha256=skUndgUatx2F5rjg2tBZLutB8k9B9Cjy-cUeglCDdwc,45314
+pipecat/services/elevenlabs/stt.py,sha256=c-6GDeyZCMcXu4FmcG0vugBRsUnq8Iz_L9XX_Y_8TlM,29453
+pipecat/services/elevenlabs/tts.py,sha256=uKN7fu10MsBR9iRhadQoF3OeVZb0efyDDB4Ru8Z3E-Q,45800
 pipecat/services/fal/__init__.py,sha256=z_kfZETvUcKy68Lyvni4B-RtdkOvz3J3eh6sFDVKq6M,278
 pipecat/services/fal/image.py,sha256=vArKLKrIGoZfw_xeZY_E7zbUzfzVsScj-R7mOmVqjRQ,4585
 pipecat/services/fal/stt.py,sha256=-5tw7N8srBJTS0Q65SN4csmLkIB6cLHR9pXKimxg55o,9678
@@ -237,7 +238,7 @@ pipecat/services/google/__init__.py,sha256=MDd6-gaugR1cUaa5cRxBJEEoo6bCnn0TBMWh8
 pipecat/services/google/frames.py,sha256=_HHljqYg7x0wh6nTRLqKaavThuMxkKFsDeLAFgVutmU,2277
 pipecat/services/google/google.py,sha256=D_GWyJQxnJmJ0sM8SLwcxom5e8snF3W3IhsEjTM7Uqg,507
 pipecat/services/google/image.py,sha256=LQYIctDIB31udYvk3meC9EXTY7VDdWb_veCTFEltTRU,4674
-pipecat/services/google/llm.py,sha256=EasDVLh5GwFy2IA7zazFZXO2ZiwRCQuo-biYUvUxC6c,40129
+pipecat/services/google/llm.py,sha256=lwb9tjqOMUjPdAZB7py-femsNt_Q6Ekw-9ZP_4OSykg,40805
 pipecat/services/google/llm_openai.py,sha256=cJDSKFOFFbBxWdsRC2f2kuPa_lpi-DgnfaPJLNsz82E,7520
 pipecat/services/google/llm_vertex.py,sha256=0UL2U0aDATWTAWYh-ypTNihF4RS1tsl_E4KwPhSQ76c,8137
 pipecat/services/google/rtvi.py,sha256=PZb1yVny5YG7_XmJRXPzs3iYapeQ4XHreFN1v6KwTGM,3014
@@ -280,7 +281,7 @@ pipecat/services/nim/llm.py,sha256=o4WPGI6kOmSiMV7WwOZ0cNEAoq9hW4Aqs2R8X7c9i94,4
 pipecat/services/ollama/__init__.py,sha256=aw-25zYsR8LR74OFFlMKMTnJjaKwOzdPWVsClueNRkI,255
 pipecat/services/ollama/llm.py,sha256=rfpG92LRHGJlpENKhF6ld8CLVS9DxlKW-WRVNldOIGs,1605
 pipecat/services/openai/__init__.py,sha256=V0ZVa8PzEm3hmcStYICbAsYwfgk4ytZ6kiQoq9UZPmI,354
-pipecat/services/openai/base_llm.py,sha256=mrHRwYL-0lYr0BhJMg_ByTfqY2no6T8DOrhqMDztBlY,21518
+pipecat/services/openai/base_llm.py,sha256=OYzxsbSw49FH6CoY6au95PEs7W3JClkt-IM8gFRP7jI,22066
 pipecat/services/openai/image.py,sha256=3e3h-dVQ6DQuQE7fp8akXwRMd-oYOdGuZg7RCOjHu9A,2994
 pipecat/services/openai/llm.py,sha256=_aKtz1VebSFUUenT3tH6mBW9pSCm65_u45cDu_dkTzs,7396
 pipecat/services/openai/stt.py,sha256=Idf0k73kxFyDgNRBt62MFpoKKNsBV9bwvJteJ6MGWzQ,2419
@@ -339,7 +340,7 @@ pipecat/services/together/llm.py,sha256=VSayO-U6g9Ld0xK9CXRQPUsd5gWJKtiA8qDAyXgs
 pipecat/services/ultravox/__init__.py,sha256=EoHCSXI2o0DFQslELgkhAGZtxDj63gZi-9ZEhXljaKE,259
 pipecat/services/ultravox/stt.py,sha256=uCQm_-LbycXdXRV6IE1a6Mymis6tyww7V8PnPzAQtx8,16586
 pipecat/services/vistaar/__init__.py,sha256=UFfSWFN5rbzl6NN-E_OH_MFaSYodZWNlenAU0wk-rAI,110
-pipecat/services/vistaar/llm.py,sha256=PrJIPPBh6PSKMtGRd2nYu1aIzk2covbwLEuUbZvDAVM,23114
+pipecat/services/vistaar/llm.py,sha256=aJGGf5Sn08x8XjHt9gNZ4dE5xzBPVN7Sde3P5EqeTWk,23587
 pipecat/services/whisper/__init__.py,sha256=smADmw0Fv98k7cGRuHTEcljKTO2WdZqLpJd0qsTCwH8,281
 pipecat/services/whisper/base_stt.py,sha256=VhslESPnYIeVbmnQTzmlZPV35TH49duxYTvJe0epNnE,7850
 pipecat/services/whisper/stt.py,sha256=9Qd56vWMzg3LtHikQnfgyMtl4odE6BCHDbpAn3HSWjw,17480
@@ -351,7 +352,7 @@ pipecat/sync/event_notifier.py,sha256=h50fC-RBGaGldWZx_wpgOmMIwJiq0PeNwQq5GPmfRR
 pipecat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/tests/utils.py,sha256=DEHDQV8uhCuKIqoHUPGVdUoCiKqTCG9zv5GqLXWWwvY,7870
 pipecat/transcriptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pipecat/transcriptions/language.py,sha256=-mWI1MiZbasuoqZTOBH69dAmoM7-UJzWq9rSCcrnmh4,8228
+pipecat/transcriptions/language.py,sha256=9kqmqCJF2NUTksWn0TH7-huRwtDqQzzALKzF1CnK_cY,10106
 pipecat/transports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/transports/base_input.py,sha256=AkdE-j9UksjIrUGJc7laMOaknXgOS7L22D5sehZ-6ew,20176
 pipecat/transports/base_output.py,sha256=T_NfU38sT6wKxXF1jA7hW5eLhTK11pundQBxAojswW8,36723
@@ -416,7 +417,7 @@ pipecat/utils/tracing/service_decorators.py,sha256=fwzxFpi8DJl6BJbK74G0UEB4ccMJg
 pipecat/utils/tracing/setup.py,sha256=7TEgPNpq6M8lww8OQvf0P9FzYc5A30xICGklVA-fua0,2892
 pipecat/utils/tracing/turn_context_provider.py,sha256=ikon3plFOx0XbMrH6DdeHttNpb-U0gzMZIm3bWLc9eI,2485
 pipecat/utils/tracing/turn_trace_observer.py,sha256=dma16SBJpYSOE58YDWy89QzHyQFc_9gQZszKeWixuwc,9725
-dv_pipecat_ai-0.0.85.dev854.dist-info/METADATA,sha256=bO3NZWI6qyHGO6asSfaEk4uIxnYPnOAp3BQDzr-sf1w,32955
-dv_pipecat_ai-0.0.85.dev854.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_pipecat_ai-0.0.85.dev854.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
-dv_pipecat_ai-0.0.85.dev854.dist-info/RECORD,,
+dv_pipecat_ai-0.0.85.dev857.dist-info/METADATA,sha256=1YE1UyNWwkyJEw2VRFSI8Bz80M609nvfhbNMCR1LBs0,32955
+dv_pipecat_ai-0.0.85.dev857.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dv_pipecat_ai-0.0.85.dev857.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
+dv_pipecat_ai-0.0.85.dev857.dist-info/RECORD,,

pipecat/metrics/connection_metrics.py

@@ -0,0 +1,45 @@
+"""Connection metrics data models for Pipecat framework.
+
+This module extends the core metrics system with connection-specific metrics
+including connection establishment times, retry attempts, and network latencies.
+"""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+from pipecat.metrics.metrics import MetricsData
+
+
+class ConnectionMetricsData(MetricsData):
+    """Unified connection and reconnection metrics data.
+
+    Handles both initial connection establishment and reconnection scenarios.
+    For initial connections, use connect_time, success, connection_attempts.
+    For reconnections, use reconnect_count, downtime, reconnect_success, reason.
+
+    Parameters:
+        connect_time: Time taken to establish connection in seconds.
+        success: Whether the connection attempt was successful.
+        connection_attempts: Number of connection attempts made.
+        error_message: Error message if connection failed.
+        connection_type: Type of connection (websocket, http, etc.).
+        reconnect_count: Number of reconnection attempts (for reconnection scenarios).
+        downtime: Time connection was down in seconds (for reconnection scenarios).
+        reconnect_success: Whether reconnection was successful (for reconnection scenarios).
+        reason: Reason for reconnection (for reconnection scenarios).
+    """
+
+    connect_time: Optional[float] = None
+    success: bool = True
+    connection_attempts: int = 1
+    error_message: Optional[str] = None
+    connection_type: Optional[str] = None
+    
+    # Reconnection-specific fields
+    reconnect_count: Optional[int] = None
+    downtime: Optional[float] = None
+    reconnect_success: Optional[bool] = None
+    reason: Optional[str] = None
+
+

pipecat/processors/frame_processor.py

@@ -436,10 +436,53 @@ class FrameProcessor(BaseObject):
             if frame:
                 await self.push_frame(frame)
 
+    async def start_connection_metrics(self):
+        """Start connection establishment metrics collection."""
+        if self.can_generate_metrics() and self.metrics_enabled:
+            await self._metrics.start_connection_metrics()
+
+    async def stop_connection_metrics(
+        self, 
+        success: bool = True, 
+        error: str = None,
+        connection_type: str = None
+    ):
+        """Stop connection metrics collection and emit metrics frame.
+        
+        Args:
+            success: Whether the connection was successful.
+            error: Error message if connection failed.
+            connection_type: Type of connection (websocket, http, etc.).
+        """
+        if self.can_generate_metrics() and self.metrics_enabled:
+            frame = await self._metrics.stop_connection_metrics(success, error, connection_type)
+            if frame:
+                await self.push_frame(frame)
+
+
+    async def start_reconnection_metrics(self):
+        """Start reconnection metrics collection."""
+        if self.can_generate_metrics() and self.metrics_enabled:
+            await self._metrics.start_reconnection_metrics()
+
+    async def stop_reconnection_metrics(self, success: bool = True, reason: str = None):
+        """Stop reconnection metrics collection and emit metrics frame.
+        
+        Args:
+            success: Whether the reconnection was successful.
+            reason: Reason for reconnection.
+        """
+        if self.can_generate_metrics() and self.metrics_enabled:
+            frame = await self._metrics.stop_reconnection_metrics(success, reason)
+            if frame:
+                await self.push_frame(frame)
+
+
     async def stop_all_metrics(self):
         """Stop all active metrics collection."""
         await self.stop_ttfb_metrics()
         await self.stop_processing_metrics()
+        await self.stop_connection_metrics()
 
     def create_task(self, coroutine: Coroutine, name: Optional[str] = None) -> asyncio.Task:
         """Create a new task managed by this processor.
@@ -811,7 +854,7 @@ class FrameProcessor(BaseObject):
         Returns:
             True if the processor has been started.
         """
-        if not self.__started:
+        if not self.__started and not isinstance(frame, SystemFrame):
             self.logger.error(f"{self} Trying to process {frame} but StartFrame not received yet")
         return self.__started
 

pipecat/processors/metrics/frame_processor_metrics.py

@@ -20,6 +20,9 @@ from pipecat.metrics.metrics import (
     TTFBMetricsData,
     TTSUsageMetricsData,
 )
+from pipecat.metrics.connection_metrics import (
+    ConnectionMetricsData,
+)
 from pipecat.utils.asyncio.task_manager import BaseTaskManager
 from pipecat.utils.base_object import BaseObject
 
@@ -46,6 +49,13 @@ class FrameProcessorMetrics(BaseObject):
         self._last_ttfb_time = 0
         self._should_report_ttfb = True
         self._logger = logger
+        
+        # Connection metrics state
+        self._start_connection_time = 0
+        self._connection_attempts = 0
+        self._last_connection_error = None
+        self._reconnection_start_time = 0
+        self._reconnect_count = 0
 
     async def setup(self, task_manager: BaseTaskManager):
         """Set up the metrics collector with a task manager.
@@ -195,3 +205,101 @@ class FrameProcessorMetrics(BaseObject):
         )
         self._logger.debug(f"{self._processor_name()} usage characters: {characters.value}")
         return MetricsFrame(data=[characters])
+
+    async def start_connection_metrics(self):
+        """Start measuring connection establishment time."""
+        self._start_connection_time = time.time()
+        self._connection_attempts += 1
+        self._last_connection_error = None
+
+    async def stop_connection_metrics(
+        self, 
+        success: bool = True, 
+        error: str = None,
+        connection_type: str = None
+    ):
+        """Stop connection measurement and generate metrics frame.
+
+        Args:
+            success: Whether the connection was successful.
+            error: Error message if connection failed.
+            connection_type: Type of connection (websocket, http, etc.).
+
+        Returns:
+            MetricsFrame containing connection data, or None if not measuring.
+        """
+        if self._start_connection_time == 0:
+            return None
+
+        connect_time = time.time() - self._start_connection_time
+        
+        if not success:
+            self._last_connection_error = error
+        
+        logstr = f"{self._processor_name()} connection "
+        logstr += "successful" if success else f"failed: {error}"
+        logstr += f" (attempt #{self._connection_attempts}, {connect_time:.3f}s)"
+        
+        if success:
+            self._logger.debug(logstr)
+        else:
+            self._logger.warning(logstr)
+        
+        connection_data = ConnectionMetricsData(
+            processor=self._processor_name(),
+            model=self._model_name(),
+            connect_time=round(connect_time, 3),
+            success=success,
+            connection_attempts=self._connection_attempts,
+            error_message=error,
+            connection_type=connection_type
+        )
+        
+        self._start_connection_time = 0
+        return MetricsFrame(data=[connection_data])
+
+
+    async def start_reconnection_metrics(self):
+        """Start measuring reconnection downtime."""
+        self._reconnection_start_time = time.time()
+        self._reconnect_count += 1
+
+    async def stop_reconnection_metrics(
+        self, 
+        success: bool = True, 
+        reason: str = None
+    ):
+        """Stop reconnection measurement and generate metrics frame.
+
+        Args:
+            success: Whether the reconnection was successful.
+            reason: Reason for reconnection.
+
+        Returns:
+            MetricsFrame containing reconnection data, or None if not measuring.
+        """
+        if self._reconnection_start_time == 0:
+            return None
+
+        downtime = time.time() - self._reconnection_start_time
+        
+        logstr = f"{self._processor_name()} reconnection #{self._reconnect_count} "
+        logstr += "successful" if success else "failed"
+        logstr += f" (downtime: {downtime:.3f}s)"
+        if reason:
+            logstr += f" - {reason}"
+        
+        self._logger.debug(logstr)
+        
+        reconnection_data = ConnectionMetricsData(
+            processor=self._processor_name(),
+            model=self._model_name(),
+            reconnect_count=self._reconnect_count,
+            downtime=round(downtime, 3),
+            reconnect_success=success,
+            reason=reason
+        )
+        
+        self._reconnection_start_time = 0
+        return MetricsFrame(data=[reconnection_data])
+

pipecat/services/deepgram/stt.py

@@ -388,6 +388,7 @@ class DeepgramSTTService(STTService):
 
     async def _connect(self):
         self.logger.debug("Attempting to connect to Deepgram...")
+        await self.start_connection_metrics()
 
         loop = asyncio.get_running_loop()
         for attempt in range(self._max_connect_retries):
@@ -489,6 +490,8 @@ class DeepgramSTTService(STTService):
                             elapsed_ms,
                             diagnostics,
                         )
+                        await self.stop_connection_metrics(success=True, connection_type="websocket")
+                        await self.stop_reconnection_metrics(success=True, reason="successful_reconnection")
                         return  # Exit the method on success
 
                 self.logger.warning(
@@ -524,6 +527,12 @@ class DeepgramSTTService(STTService):
         error_msg = (
             f"{self}: unable to connect to Deepgram after {self._max_connect_retries} attempts."
         )
+        await self.stop_connection_metrics(
+            success=False, 
+            error=f"Failed after {self._max_connect_retries} attempts", 
+            connection_type="websocket"
+        )
+        await self.stop_reconnection_metrics(success=False, reason="max_retries_exceeded")
         self.logger.error(error_msg)
         await self.push_error(ErrorFrame(error_msg, fatal=True))
 
@@ -589,6 +598,7 @@ class DeepgramSTTService(STTService):
         # NOTE(aleix): we don't disconnect (i.e. call finish on the connection)
         # because this triggers more errors internally in the Deepgram SDK. So,
         # we just forget about the previous connection and create a new one.
+        await self.start_reconnection_metrics()
         await self._connect()
 
     async def _on_speech_started(self, *args, **kwargs):

pipecat/services/elevenlabs/stt.py

@@ -34,7 +34,7 @@ from pipecat.frames.frames import (
 )
 from pipecat.processors.frame_processor import FrameDirection
 from pipecat.services.stt_service import SegmentedSTTService, WebsocketSTTService
-from pipecat.transcriptions.language import Language
+from pipecat.transcriptions.language import Language, resolve_language
 from pipecat.utils.time import time_now_iso8601
 from pipecat.utils.tracing.service_decorators import traced_stt
 
@@ -61,7 +61,7 @@ def language_to_elevenlabs_language(language: Language) -> Optional[str]:
     Returns:
         The corresponding ElevenLabs language code, or None if not supported.
     """
-    BASE_LANGUAGES = {
+    LANGUAGE_MAP = {
         Language.AF: "afr",  # Afrikaans
         Language.AM: "amh",  # Amharic
         Language.AR: "ara",  # Arabic
@@ -163,21 +163,7 @@ def language_to_elevenlabs_language(language: Language) -> Optional[str]:
         Language.ZU: "zul",  # Zulu
     }
 
-    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]  # 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
+    return resolve_language(language, LANGUAGE_MAP, use_base_code=False)
 
 
 class ElevenLabsSTTService(SegmentedSTTService):
@@ -365,8 +351,8 @@ class ElevenLabsSTTService(SegmentedSTTService):
                 )
 
         except Exception as e:
-            logger.error(f"ElevenLabs STT error: {e}")
-            yield ErrorFrame(f"ElevenLabs STT error: {str(e)}")
+            logger.error(f"{self} exception: {e}")
+            yield ErrorFrame(error=f"{self} error: {e}")
 
 
 def audio_format_from_sample_rate(sample_rate: int) -> str:
@@ -414,12 +400,6 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
 
     By default, uses manual commit strategy where Pipecat's VAD controls when to
     commit transcript segments, providing consistency with other STT services.
-
-    Important:
-        When using manual commit strategy with Pipecat's VAD, it is recommended to set
-        the VAD `stop_secs` parameter to at least 0.5 seconds. Lower values may result
-        in incomplete transcriptions due to a known limitation in the ElevenLabs model
-        where audio sent near the commit boundary may not be fully processed.
     """
 
     class InputParams(BaseModel):
@@ -436,11 +416,6 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
                 Only used when commit_strategy is VAD. None uses ElevenLabs default.
             min_silence_duration_ms: Minimum silence duration for VAD (50-2000ms).
                 Only used when commit_strategy is VAD. None uses ElevenLabs default.
-
-        Note:
-            When using manual commit strategy, ensure Pipecat's VAD `stop_secs` is set to
-            at least 0.5 seconds to avoid incomplete transcriptions. This is a known
-            limitation of the ElevenLabs model.
         """
 
         language_code: Optional[str] = None
@@ -469,10 +444,6 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             sample_rate: Audio sample rate in Hz. If not provided, uses the pipeline's rate.
             params: Configuration parameters for the STT service.
             **kwargs: Additional arguments passed to WebsocketSTTService.
-
-        Note:
-            When using manual commit strategy (default), configure Pipecat's VAD with
-            `stop_secs` of at least 0.5 seconds to ensure complete transcriptions.
         """
         super().__init__(
             sample_rate=sample_rate,
@@ -746,12 +717,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             logger.error(f"ElevenLabs input error: {error_msg}")
             await self.push_error(ErrorFrame(f"Input error: {error_msg}"))
 
-        elif message_type in [
-            "auth_error",
-            "quota_exceeded",
-            "transcriber_error",
-            "error",
-        ]:
+        elif message_type in ["auth_error", "quota_exceeded", "transcriber_error", "error"]:
             error_msg = data.get("error", data.get("message", "Unknown error"))
             logger.error(f"ElevenLabs error ({message_type}): {error_msg}")
             await self.push_error(ErrorFrame(f"{message_type}: {error_msg}"))

pipecat/services/elevenlabs/tts.py

@@ -519,6 +519,7 @@ class ElevenLabsTTSService(AudioContextWordTTSService):
                 return
 
             self.logger.debug("Connecting to ElevenLabs")
+            await self.start_connection_metrics()
 
             voice_id = self._voice_id
             model = self.model_name
@@ -551,14 +552,19 @@ class ElevenLabsTTSService(AudioContextWordTTSService):
                 additional_headers={"xi-api-key": self._api_key},
             )
 
+            await self.stop_connection_metrics(success=True, connection_type="websocket")
+            await self.stop_reconnection_metrics(success=True, reason="successful_reconnection")
             await self._call_event_handler("on_connected")
         except Exception as e:
             self.logger.error(f"{self} initialization error: {e}")
+            await self.stop_connection_metrics(success=False, error=str(e), connection_type="websocket")
+            await self.stop_reconnection_metrics(success=False, reason="connection_failed")
             self._websocket = None
             await self._call_event_handler("on_connection_error", f"{e}")
 
     async def _disconnect_websocket(self):
         try:
+            await self.start_reconnection_metrics()
             await self.stop_all_metrics()
 
             if self._websocket:

pipecat/services/google/llm.py

@@ -760,12 +760,19 @@ class GoogleLLMService(LLMService):
 
         generation_config = GenerateContentConfig(system_instruction=system)
 
-        # Use the new google-genai client's async method
-        response = await self._client.aio.models.generate_content(
-            model=self._model_name,
-            contents=messages,
-            config=generation_config,
-        )
+        await self.start_connection_metrics()
+        
+        try:
+            # Use the new google-genai client's async method
+            response = await self._client.aio.models.generate_content(
+                model=self._model_name,
+                contents=messages,
+                config=generation_config,
+            )
+            await self.stop_connection_metrics(success=True, connection_type="grpc")
+        except Exception as e:
+            await self.stop_connection_metrics(success=False, error=str(e), connection_type="grpc")
+            raise
 
         # Extract text from response
         if response.candidates and response.candidates[0].content:
@@ -849,11 +856,19 @@ class GoogleLLMService(LLMService):
         )
 
         await self.start_ttfb_metrics()
-        return await self._client.aio.models.generate_content_stream(
-            model=self._model_name,
-            contents=messages,
-            config=generation_config,
-        )
+        await self.start_connection_metrics()
+        
+        try:
+            result = await self._client.aio.models.generate_content_stream(
+                model=self._model_name,
+                contents=messages,
+                config=generation_config,
+            )
+            await self.stop_connection_metrics(success=True, connection_type="grpc")
+            return result
+        except Exception as e:
+            await self.stop_connection_metrics(success=False, error=str(e), connection_type="grpc")
+            raise
 
     async def _stream_content_specific_context(
         self, context: OpenAILLMContext

pipecat/services/openai/base_llm.py

@@ -205,20 +205,29 @@ class BaseOpenAILLMService(LLMService):
         """
         params = self.build_chat_completion_params(params_from_context)
 
-        if self._retry_on_timeout:
-            try:
-                chunks = await asyncio.wait_for(
-                    self._client.chat.completions.create(**params), timeout=self._retry_timeout_secs
-                )
-                return chunks
-            except (APITimeoutError, asyncio.TimeoutError):
-                # Retry, this time without a timeout so we get a response
-                logger.debug(f"{self}: Retrying chat completion due to timeout")
+        await self.start_connection_metrics()
+        
+        try:
+            if self._retry_on_timeout:
+                try:
+                    chunks = await asyncio.wait_for(
+                        self._client.chat.completions.create(**params), timeout=self._retry_timeout_secs
+                    )
+                    await self.stop_connection_metrics(success=True, connection_type="http")
+                    return chunks
+                except (APITimeoutError, asyncio.TimeoutError):
+                    # Retry, this time without a timeout so we get a response
+                    logger.debug(f"{self}: Retrying chat completion due to timeout")
+                    chunks = await self._client.chat.completions.create(**params)
+                    await self.stop_connection_metrics(success=True, connection_type="http")
+                    return chunks
+            else:
                 chunks = await self._client.chat.completions.create(**params)
+                await self.stop_connection_metrics(success=True, connection_type="http")
                 return chunks
-        else:
-            chunks = await self._client.chat.completions.create(**params)
-            return chunks
+        except Exception as e:
+            await self.stop_connection_metrics(success=False, error=str(e), connection_type="http")
+            raise
 
     def build_chat_completion_params(self, params_from_context: OpenAILLMInvocationParams) -> dict:
         """Build parameters for chat completion request.

pipecat/services/vistaar/llm.py

@@ -344,9 +344,12 @@ class VistaarLLMService(LLMService):
             logger.error(f"Failed to generate JWT token: {e}")
             raise
 
+        await self.start_connection_metrics()
+        
         try:
             # Use httpx to handle SSE streaming
             async with self._client.stream("GET", url, headers=headers) as response:
+                await self.stop_connection_metrics(success=True, connection_type="http")
                 self._current_response = response  # Store for potential cancellation
                 response.raise_for_status()
 
@@ -364,14 +367,17 @@ class VistaarLLMService(LLMService):
                     yield line
 
         except httpx.HTTPStatusError as e:
+            await self.stop_connection_metrics(success=False, error=f"HTTP {e.response.status_code}", connection_type="http")
             logger.error(
                 f"Vistaar HTTP error - Status: {e.response.status_code}, URL: {url}, Response: {e.response.text if hasattr(e.response, 'text') else 'N/A'}"
             )
             raise
         except httpx.TimeoutException as e:
+            await self.stop_connection_metrics(success=False, error="Timeout", connection_type="http")
             logger.error(f"Vistaar timeout error - URL: {url}, Timeout: {self._timeout}s")
             raise
         except Exception as e:
+            await self.stop_connection_metrics(success=False, error=str(e), connection_type="http")
             logger.error(
                 f"Vistaar unexpected error - Type: {type(e).__name__}, Message: {str(e)}, URL: {url}"
             )

pipecat/transcriptions/language.py

@@ -569,3 +569,53 @@ class Language(StrEnum):
     # Zulu
     ZU = "zu"
     ZU_ZA = "zu-ZA"
+
+
+def resolve_language(
+    language: Language, language_map: dict[Language, str], use_base_code: bool = True
+) -> str:
+    """Resolve a Language enum to a service-specific language code.
+
+    Checks the language map first, then falls back to extracting the appropriate
+    code format with a warning if not found in the verified list.
+
+    Args:
+        language: The Language enum value to convert.
+        language_map: Dictionary mapping Language enums to service language codes.
+        use_base_code: If True, extracts base code (e.g., 'en' from 'en-US').
+                      If False, uses full language code as-is.
+
+    Returns:
+        The resolved language code for the service.
+
+    Examples::
+
+        # Service expecting base codes (e.g., Cartesia)
+        >>> LANGUAGE_MAP = {Language.EN: "en", Language.ES: "es"}
+        >>> resolve_language(Language.EN_US, LANGUAGE_MAP, use_base_code=True)
+        # Logs: "Language en-US not verified. Using base code 'en'."
+        "en"
+
+        # Service expecting full codes (e.g., AWS)
+        >>> LANGUAGE_MAP = {Language.EN_US: "en-US", Language.ES_ES: "es-ES"}
+        >>> resolve_language(Language.EN_GB, LANGUAGE_MAP, use_base_code=False)
+        # Logs: "Language en-GB not verified. Using 'en-GB'."
+        "en-GB"
+    """
+    # Check if language is in the verified map
+    result = language_map.get(language)
+
+    if result is not None:
+        return result
+
+    # Not in map - fall back with warning
+    lang_str = str(language.value)
+
+    if use_base_code:
+        # Extract base code (e.g., "en" from "en-US")
+        base_code = lang_str.split("-")[0].lower()
+        # logger.warning(f"Language {language.value} not verified. Using base code '{base_code}'.")
+        return base_code
+    else:
+        # logger.warning(f"Language {language.value} not verified. Using '{lang_str}'.")
+        return lang_str