dv-pipecat-ai 0.0.82.dev857__py3-none-any.whl → 0.0.85.dev837__py3-none-any.whl

pipecat/serializers/protobuf.py

@@ -15,11 +15,12 @@ import pipecat.frames.protobufs.frames_pb2 as frame_protos
 from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
+    InputTransportMessageFrame,
     OutputAudioRawFrame,
+    OutputTransportMessageFrame,
+    OutputTransportMessageUrgentFrame,
     TextFrame,
     TranscriptionFrame,
-    TransportMessageFrame,
-    TransportMessageUrgentFrame,
 )
 from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
 
@@ -82,7 +83,7 @@ class ProtobufFrameSerializer(FrameSerializer):
             Serialized frame as bytes, or None if frame type is not serializable.
         """
         # Wrapping this messages as a JSONFrame to send
-        if isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+        if isinstance(frame, (OutputTransportMessageFrame, OutputTransportMessageUrgentFrame)):
             frame = MessageFrame(
                 data=json.dumps(frame.message),
             )
@@ -134,11 +135,11 @@ class ProtobufFrameSerializer(FrameSerializer):
         if "pts" in args_dict:
             del args_dict["pts"]
 
-        # Special handling for MessageFrame -> TransportMessageUrgentFrame
+        # Special handling for MessageFrame -> OutputTransportMessageUrgentFrame
         if class_name == MessageFrame:
             try:
                 msg = json.loads(args_dict["data"])
-                instance = TransportMessageUrgentFrame(message=msg)
+                instance = InputTransportMessageFrame(message=msg)
                 logger.debug(f"ProtobufFrameSerializer: Transport message {instance}")
             except Exception as e:
                 logger.error(f"Error parsing MessageFrame data: {e}")

pipecat/serializers/telnyx.py

@@ -29,8 +29,8 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
+    InterruptionFrame,
     StartFrame,
-    StartInterruptionFrame,
 )
 from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
 
@@ -137,7 +137,7 @@ class TelnyxFrameSerializer(FrameSerializer):
             self._hangup_attempted = True
             await self._hang_up_call()
             return None
-        elif isinstance(frame, StartInterruptionFrame):
+        elif isinstance(frame, InterruptionFrame):
             answer = {"event": "clear"}
             return json.dumps(answer)
         elif isinstance(frame, AudioRawFrame):

pipecat/serializers/twilio.py

@@ -22,10 +22,10 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
+    InterruptionFrame,
+    OutputTransportMessageFrame,
+    OutputTransportMessageUrgentFrame,
     StartFrame,
-    StartInterruptionFrame,
-    TransportMessageFrame,
-    TransportMessageUrgentFrame,
 )
 from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
 
@@ -61,6 +61,8 @@ class TwilioFrameSerializer(FrameSerializer):
         call_sid: Optional[str] = None,
         account_sid: Optional[str] = None,
         auth_token: Optional[str] = None,
+        region: Optional[str] = None,
+        edge: Optional[str] = None,
         params: Optional[InputParams] = None,
     ):
         """Initialize the TwilioFrameSerializer.
@@ -70,13 +72,42 @@ class TwilioFrameSerializer(FrameSerializer):
             call_sid: The associated Twilio Call SID (optional, but required for auto hang-up).
             account_sid: Twilio account SID (required for auto hang-up).
             auth_token: Twilio auth token (required for auto hang-up).
+            region: Twilio region (e.g., "au1", "ie1"). Must be specified with edge.
+            edge: Twilio edge location (e.g., "sydney", "dublin"). Must be specified with region.
             params: Configuration parameters.
         """
+        self._params = params or TwilioFrameSerializer.InputParams()
+
+        # Validate hangup-related parameters if auto_hang_up is enabled
+        if self._params.auto_hang_up:
+            # Validate required credentials
+            missing_credentials = []
+            if not call_sid:
+                missing_credentials.append("call_sid")
+            if not account_sid:
+                missing_credentials.append("account_sid")
+            if not auth_token:
+                missing_credentials.append("auth_token")
+
+            if missing_credentials:
+                raise ValueError(
+                    f"auto_hang_up is enabled but missing required parameters: {', '.join(missing_credentials)}"
+                )
+
+            # Validate region and edge are both provided if either is specified
+            if (region and not edge) or (edge and not region):
+                raise ValueError(
+                    "Both edge and region parameters are required if one is set. "
+                    f"Twilio's FQDN format requires both: api.{{edge}}.{{region}}.twilio.com. "
+                    f"Got: region='{region}', edge='{edge}'"
+                )
+
         self._stream_sid = stream_sid
         self._call_sid = call_sid
         self._account_sid = account_sid
         self._auth_token = auth_token
-        self._params = params or TwilioFrameSerializer.InputParams()
+        self._region = region
+        self._edge = edge
 
         self._twilio_sample_rate = self._params.twilio_sample_rate
         self._sample_rate = 0  # Pipeline input rate
@@ -122,7 +153,7 @@ class TwilioFrameSerializer(FrameSerializer):
             self._hangup_attempted = True
             await self._hang_up_call()
             return None
-        elif isinstance(frame, StartInterruptionFrame):
+        elif isinstance(frame, InterruptionFrame):
             answer = {"event": "clear", "streamSid": self._stream_sid}
             return json.dumps(answer)
         elif isinstance(frame, AudioRawFrame):
@@ -135,7 +166,7 @@ class TwilioFrameSerializer(FrameSerializer):
             if serialized_data is None or len(serialized_data) == 0:
                 # Ignoring in case we don't have audio
                 return None
-            
+
             payload = base64.b64encode(serialized_data).decode("utf-8")
             answer = {
                 "event": "media",
@@ -144,7 +175,7 @@ class TwilioFrameSerializer(FrameSerializer):
             }
 
             return json.dumps(answer)
-        elif isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+        elif isinstance(frame, (OutputTransportMessageFrame, OutputTransportMessageUrgentFrame)):
             return json.dumps(frame.message)
 
         # Return None for unhandled frames
@@ -158,25 +189,14 @@ class TwilioFrameSerializer(FrameSerializer):
             account_sid = self._account_sid
             auth_token = self._auth_token
             call_sid = self._call_sid
+            region = self._region
+            edge = self._edge
 
-            if not call_sid or not account_sid or not auth_token:
-                missing = []
-                if not call_sid:
-                    missing.append("call_sid")
-                if not account_sid:
-                    missing.append("account_sid")
-                if not auth_token:
-                    missing.append("auth_token")
-
-                logger.warning(
-                    f"Cannot hang up Twilio call: missing required parameters: {', '.join(missing)}"
-                )
-                return
+            region_prefix = f"{region}." if region else ""
+            edge_prefix = f"{edge}." if edge else ""
 
             # Twilio API endpoint for updating calls
-            endpoint = (
-                f"https://api.twilio.com/2010-04-01/Accounts/{account_sid}/Calls/{call_sid}.json"
-            )
+            endpoint = f"https://api.{edge_prefix}{region_prefix}twilio.com/2010-04-01/Accounts/{account_sid}/Calls/{call_sid}.json"
 
             # Create basic auth from account_sid and auth_token
             auth = aiohttp.BasicAuth(account_sid, auth_token)

pipecat/serializers/vi.py

@@ -0,0 +1,324 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Vodafone Idea (VI) WebSocket frame serializer for audio streaming and call management."""
+
+import base64
+import json
+from datetime import datetime, timezone
+from typing import Optional
+
+from loguru import logger
+from pydantic import BaseModel
+
+from pipecat.audio.utils import create_default_resampler
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    InputDTMFFrame,
+    KeypadEntry,
+    StartFrame,
+    StartInterruptionFrame,
+    TransportMessageFrame,
+    TransportMessageUrgentFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class VIFrameSerializer(FrameSerializer):
+    """Serializer for Vodafone Idea (VI) WebSocket protocol.
+
+    This serializer handles converting between Pipecat frames and VI's WebSocket
+    protocol for bidirectional audio streaming. It supports audio conversion, DTMF events,
+    and real-time communication with VI telephony systems.
+
+    VI WebSocket protocol requirements:
+    - PCM audio format at 8kHz sample rate
+    - 16-bit Linear PCM encoding
+    - Base64 encoded audio payloads
+    - JSON message format for control and media events
+    - Bitrate: 128 Kbps
+
+    Events (VI → Endpoint):
+    - connected: WebSocket connection established
+    - start: Stream session started with call/stream IDs
+    - media: Audio data in Base64-encoded PCM
+    - dtmf: Keypad digit pressed
+    - stop: Stream ended
+    - mark: Audio playback checkpoint confirmation
+
+    Events (Endpoint → VI):
+    - media: Send audio back to VI
+    - mark: Request acknowledgment for audio playback
+    - clear: Clear queued audio (interruption)
+    - exit: Terminate session gracefully
+    """
+
+    class InputParams(BaseModel):
+        """Configuration parameters for VIFrameSerializer.
+
+        Attributes:
+            vi_sample_rate: Sample rate used by VI, defaults to 8000 Hz (telephony standard).
+            sample_rate: Optional override for pipeline input sample rate.
+            auto_hang_up: Whether to automatically terminate call on EndFrame.
+        """
+
+        vi_sample_rate: int = 8000
+        sample_rate: Optional[int] = None
+        auto_hang_up: bool = False
+
+    def __init__(
+        self,
+        stream_id: str,
+        call_id: Optional[str] = None,
+        params: Optional[InputParams] = None,
+    ):
+        """Initialize the VIFrameSerializer.
+
+        Args:
+            stream_id: The VI stream identifier.
+            call_id: The associated VI call identifier.
+            params: Configuration parameters.
+        """
+        self._stream_id = stream_id
+        self._call_id = call_id
+        self._params = params or VIFrameSerializer.InputParams()
+
+        self._vi_sample_rate = self._params.vi_sample_rate
+        self._sample_rate = 0  # Pipeline input rate
+        self._call_ended = False
+
+        self._resampler = create_default_resampler()
+
+    @property
+    def type(self) -> FrameSerializerType:
+        """Gets the serializer type.
+
+        Returns:
+            The serializer type as TEXT for JSON WebSocket messages.
+        """
+        return FrameSerializerType.TEXT
+
+    async def setup(self, frame: StartFrame):
+        """Sets up the serializer with pipeline configuration.
+
+        Args:
+            frame: The StartFrame containing pipeline configuration.
+        """
+        self._sample_rate = self._params.sample_rate or frame.audio_in_sample_rate
+
+    async def serialize(self, frame: Frame) -> str | bytes | None:
+        """Serializes a Pipecat frame to VI WebSocket format.
+
+        Handles conversion of various frame types to VI WebSocket messages.
+        For EndFrames, initiates call termination if auto_hang_up is enabled.
+
+        Args:
+            frame: The Pipecat frame to serialize.
+
+        Returns:
+            Serialized data as JSON string, or None if the frame isn't handled.
+        """
+        if (
+            self._params.auto_hang_up
+            and not self._call_ended
+            and isinstance(frame, (EndFrame, CancelFrame))
+        ):
+            self._call_ended = True
+            # Return the exit event to terminate the VI session
+            return await self._send_exit_event()
+
+        elif isinstance(frame, StartInterruptionFrame):
+            # Clear/interrupt command for VI - clears queued audio
+            message = {
+                "event": "clear",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+            }
+            logger.debug(f"VI: Sending clear event for stream_id: {self._stream_id}")
+            return json.dumps(message)
+
+        elif isinstance(frame, AudioRawFrame):
+            if self._call_ended:
+                logger.debug("VI SERIALIZE: Skipping audio - call has ended")
+                return None
+
+            # Convert PCM audio to VI format
+            data = frame.audio
+
+            # Resample to VI sample rate (8kHz)
+            serialized_data = await self._resampler.resample(
+                data, frame.sample_rate, self._vi_sample_rate
+            )
+
+            # Encode as base64 for transmission
+            payload = base64.b64encode(serialized_data).decode("ascii")
+
+            # VI expects media event format with Base64-encoded PCM audio
+            timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+            message = {
+                "event": "media",
+                "stream_id": self._stream_id,
+                "media": {
+                    "timestamp": timestamp,
+                    "chunk": len(serialized_data),  # Chunk size in bytes
+                    "payload": payload,
+                },
+            }
+
+            return json.dumps(message)
+
+        elif isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+            # Pass through transport messages (for mark events, etc.)
+            return json.dumps(frame.message)
+
+        return None
+
+    async def _send_exit_event(self):
+        """Send an exit event to VI to terminate the session gracefully.
+
+        This method is called when auto_hang_up is enabled and an EndFrame or
+        CancelFrame is received. The exit event allows IVR logic to continue
+        after the WebSocket session ends.
+        """
+        try:
+            exit_event = {
+                "event": "exit",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+                "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            }
+
+            logger.info(
+                f"VI auto_hang_up: Sending exit event for stream_id: {self._stream_id}, call_id: {self._call_id}"
+            )
+            return json.dumps(exit_event)
+        except Exception as e:
+            logger.error(f"VI auto_hang_up: Failed to create exit event: {e}")
+            return None
+
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        """Deserializes VI WebSocket data to Pipecat frames.
+
+        Handles conversion of VI media events to appropriate Pipecat frames.
+
+        Args:
+            data: The raw WebSocket data from VI.
+
+        Returns:
+            A Pipecat frame corresponding to the VI event, or None if unhandled.
+        """
+        try:
+            message = json.loads(data)
+        except json.JSONDecodeError:
+            logger.error(f"Invalid JSON received from VI: {data}")
+            return None
+
+        # Log all incoming events for debugging and monitoring
+        event = message.get("event")
+        logger.debug(
+            f"VI INCOMING EVENT: {event} - stream_id: {self._stream_id}, call_id: {self._call_id}"
+        )
+
+        if event == "media":
+            # Handle incoming audio data from VI
+            media = message.get("media", {})
+            payload_base64 = media.get("payload")
+
+            if not payload_base64:
+                logger.warning("VI DESERIALIZE: No payload in VI media message")
+                return None
+
+            try:
+                payload = base64.b64decode(payload_base64)
+                chunk_size = len(payload)
+
+                # Log chunk info (optional)
+                logger.debug(
+                    f"VI DESERIALIZE: Received audio from VI - {chunk_size} bytes at {self._vi_sample_rate}Hz"
+                )
+
+            except Exception as e:
+                logger.error(f"VI DESERIALIZE: Error decoding VI audio payload: {e}")
+                return None
+
+            # Convert from VI sample rate (8kHz) to pipeline sample rate
+            deserialized_data = await self._resampler.resample(
+                payload,
+                self._vi_sample_rate,
+                self._sample_rate,
+            )
+
+            audio_frame = InputAudioRawFrame(
+                audio=deserialized_data,
+                num_channels=1,  # VI uses mono audio
+                sample_rate=self._sample_rate,
+            )
+            return audio_frame
+
+        elif event == "dtmf":
+            # Handle DTMF events
+            dtmf_data = message.get("dtmf", {})
+            digit = dtmf_data.get("digit")
+
+            if digit:
+                try:
+                    logger.info(f"VI: Received DTMF digit: {digit}")
+                    return InputDTMFFrame(KeypadEntry(digit))
+                except ValueError:
+                    logger.warning(f"Invalid DTMF digit from VI: {digit}")
+                    return None
+
+        elif event == "connected":
+            # Handle connection event
+            logger.info(f"VI connection established: {message}")
+            return None
+
+        elif event == "start":
+            # Handle stream start event
+            logger.info(f"VI stream started: {message}")
+            return None
+
+        elif event == "stop":
+            # Handle stream stop event
+            logger.info(f"VI stream stopped: {message}")
+            # Don't end the call here, wait for explicit exit or call end
+            return None
+
+        elif event == "mark":
+            # Handle mark event - checkpoint confirming audio playback completion
+            mark_data = message.get("mark", {})
+            mark_name = mark_data.get("name", "unknown")
+            logger.info(f"VI mark event received: {mark_name}")
+            # Mark events are informational, no frame to return
+            return None
+
+        elif event == "error":
+            # Handle error events
+            error_msg = message.get("error", "Unknown error")
+            logger.error(f"VI error: {error_msg}")
+            return None
+
+        elif event == "exit":
+            # Handle exit event from VI
+            logger.info("VI exit event received - terminating session")
+            self._call_ended = True
+            return CancelFrame()
+
+        elif event == "call_end" or event == "callEnd":
+            # Handle call end event (if VI sends this)
+            logger.info("VI call end event received")
+            self._call_ended = True
+            return CancelFrame()
+
+        else:
+            logger.debug(f"VI UNHANDLED EVENT: {event}")
+
+        return None

pipecat/services/ai_service.py

@@ -97,9 +97,7 @@ class AIService(FrameProcessor):
         pass
 
     async def _update_settings(self, settings: Mapping[str, Any]):
-        from pipecat.services.openai_realtime_beta.events import (
-            SessionProperties,
-        )
+        from pipecat.services.openai.realtime.events import SessionProperties
 
         for key, value in settings.items():
             logger.debug("Update request for:", key, value)
@@ -111,9 +109,7 @@ class AIService(FrameProcessor):
                 logger.debug("Attempting to update", key, value)
 
                 try:
-                    from pipecat.services.openai_realtime_beta.events import (
-                        TurnDetection,
-                    )
+                    from pipecat.services.openai.realtime.events import TurnDetection
 
                     if isinstance(self._session_properties, SessionProperties):
                         current_properties = self._session_properties

pipecat/services/anthropic/llm.py

@@ -42,7 +42,6 @@ from pipecat.frames.frames import (
     LLMTextFrame,
     LLMUpdateSettingsFrame,
     UserImageRawFrame,
-    VisionImageRawFrame,
 )
 from pipecat.metrics.metrics import LLMTokenUsage
 from pipecat.processors.aggregators.llm_context import LLMContext
@@ -152,7 +151,7 @@ class AnthropicLLMService(LLMService):
         self,
         *,
         api_key: str,
-        model: str = "claude-sonnet-4-20250514",
+        model: str = "claude-sonnet-4-5-20250929",
         params: Optional[InputParams] = None,
         client=None,
         retry_timeout_secs: Optional[float] = 5.0,
@@ -163,7 +162,7 @@ class AnthropicLLMService(LLMService):
 
         Args:
             api_key: Anthropic API key for authentication.
-            model: Model name to use. Defaults to "claude-sonnet-4-20250514".
+            model: Model name to use. Defaults to "claude-sonnet-4-5-20250929".
             params: Optional model parameters for inference.
             client: Optional custom Anthropic client instance.
             retry_timeout_secs: Request timeout in seconds for retry logic.
@@ -495,12 +494,6 @@ class AnthropicLLMService(LLMService):
             context = frame.context
         elif isinstance(frame, LLMMessagesFrame):
             context = AnthropicLLMContext.from_messages(frame.messages)
-        elif isinstance(frame, VisionImageRawFrame):
-            # This is only useful in very simple pipelines because it creates
-            # a new context. Generally we want a context manager to catch
-            # UserImageRawFrames coming through the pipeline and add them
-            # to the context.
-            context = AnthropicLLMContext.from_image_frame(frame)
         elif isinstance(frame, LLMUpdateSettingsFrame):
             await self._update_settings(frame.settings)
         elif isinstance(frame, LLMEnablePromptCachingFrame):
@@ -626,22 +619,6 @@ class AnthropicLLMContext(OpenAILLMContext):
         self._restructure_from_openai_messages()
         return self
 
-    @classmethod
-    def from_image_frame(cls, frame: VisionImageRawFrame) -> "AnthropicLLMContext":
-        """Create context from a vision image frame.
-
-        Args:
-            frame: The vision image frame to process.
-
-        Returns:
-            New Anthropic context with the image message.
-        """
-        context = cls()
-        context.add_image_frame_message(
-            format=frame.format, size=frame.size, image=frame.image, text=frame.text
-        )
-        return context
-
     def set_messages(self, messages: List):
         """Set the messages list and reset cache tracking.
 

pipecat/services/assemblyai/models.py

@@ -108,6 +108,8 @@ class AssemblyAIConnectionParams(BaseModel):
         end_of_turn_confidence_threshold: Confidence threshold for end-of-turn detection.
         min_end_of_turn_silence_when_confident: Minimum silence duration when confident about end-of-turn.
         max_turn_silence: Maximum silence duration before forcing end-of-turn.
+        keyterms_prompt: List of key terms to guide transcription. Will be JSON serialized before sending.
+        speech_model: Select between English and multilingual models. Defaults to "universal-streaming-english".
     """
 
     sample_rate: int = 16000
@@ -117,3 +119,7 @@ class AssemblyAIConnectionParams(BaseModel):
     end_of_turn_confidence_threshold: Optional[float] = None
     min_end_of_turn_silence_when_confident: Optional[int] = None
     max_turn_silence: Optional[int] = None
+    keyterms_prompt: Optional[List[str]] = None
+    speech_model: Literal["universal-streaming-english", "universal-streaming-multilingual"] = (
+        "universal-streaming-english"
+    )

pipecat/services/assemblyai/stt.py

@@ -174,11 +174,16 @@ class AssemblyAISTTService(STTService):
 
     def _build_ws_url(self) -> str:
         """Build WebSocket URL with query parameters using urllib.parse.urlencode."""
-        params = {
-            k: str(v).lower() if isinstance(v, bool) else v
-            for k, v in self._connection_params.model_dump().items()
-            if v is not None
-        }
+        params = {}
+        for k, v in self._connection_params.model_dump().items():
+            if v is not None:
+                if k == "keyterms_prompt":
+                    params[k] = json.dumps(v)
+                elif isinstance(v, bool):
+                    params[k] = str(v).lower()
+                else:
+                    params[k] = v
+
         if params:
             query_string = urlencode(params)
             return f"{self._api_endpoint_base_url}?{query_string}"
@@ -197,6 +202,8 @@ class AssemblyAISTTService(STTService):
             )
             self._connected = True
             self._receive_task = self.create_task(self._receive_task_handler())
+
+            await self._call_event_handler("on_connected")
         except Exception as e:
             logger.error(f"Failed to connect to AssemblyAI: {e}")
             self._connected = False
@@ -238,6 +245,7 @@ class AssemblyAISTTService(STTService):
             self._websocket = None
             self._connected = False
             self._receive_task = None
+            await self._call_event_handler("on_disconnected")
 
     async def _receive_task_handler(self):
         """Handle incoming WebSocket messages."""

pipecat/services/asyncai/tts.py

@@ -20,8 +20,8 @@ from pipecat.frames.frames import (
     EndFrame,
     ErrorFrame,
     Frame,
+    InterruptionFrame,
     StartFrame,
-    StartInterruptionFrame,
     TTSAudioRawFrame,
     TTSStartedFrame,
     TTSStoppedFrame,
@@ -119,7 +119,6 @@ class AsyncAITTSService(InterruptibleTTSService):
         """
         super().__init__(
             aggregate_sentences=aggregate_sentences,
-            push_text_frames=False,
             pause_frame_processing=True,
             push_stop_frames=True,
             sample_rate=sample_rate,
@@ -236,6 +235,8 @@ class AsyncAITTSService(InterruptibleTTSService):
             }
 
             await self._get_websocket().send(json.dumps(init_msg))
+
+            await self._call_event_handler("on_connected")
         except Exception as e:
             logger.error(f"{self} initialization error: {e}")
             self._websocket = None
@@ -253,6 +254,7 @@ class AsyncAITTSService(InterruptibleTTSService):
         finally:
             self._websocket = None
             self._started = False
+            await self._call_event_handler("on_disconnected")
 
     def _get_websocket(self):
         if self._websocket:
@@ -275,7 +277,7 @@ class AsyncAITTSService(InterruptibleTTSService):
             direction: The direction to push the frame.
         """
         await super().push_frame(frame, direction)
-        if isinstance(frame, (TTSStoppedFrame, StartInterruptionFrame)):
+        if isinstance(frame, (TTSStoppedFrame, InterruptionFrame)):
             self._started = False
 
     async def _receive_messages(self):