dv-pipecat-ai 0.0.74.dev770__py3-none-any.whl → 0.0.82.dev776__py3-none-any.whl

pipecat/services/openai/base_llm.py

@@ -6,6 +6,7 @@
 
 """Base OpenAI LLM service implementation."""
 
+import asyncio
 import base64
 import json
 from typing import Any, Dict, List, Mapping, Optional
@@ -14,6 +15,7 @@ import httpx
 from loguru import logger
 from openai import (
     NOT_GIVEN,
+    APITimeoutError,
     AsyncOpenAI,
     AsyncStream,
     DefaultAsyncHttpxClient,
@@ -37,7 +39,6 @@ from pipecat.processors.aggregators.openai_llm_context import (
 )
 from pipecat.processors.frame_processor import FrameDirection
 from pipecat.services.llm_service import FunctionCallFromLLM, LLMService
-from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 from pipecat.utils.tracing.service_decorators import traced_llm
 
 
@@ -48,16 +49,6 @@ class BaseOpenAILLMService(LLMService):
     to an OpenAILLMContext object. The context defines what is sent to the LLM for
     completion, including user, assistant, and system messages, as well as tool
     choices and function call configurations.
-
-    Args:
-        model: The OpenAI model name to use (e.g., "gpt-4.1", "gpt-4o").
-        api_key: OpenAI API key. If None, uses environment variable.
-        base_url: Custom base URL for OpenAI API. If None, uses default.
-        organization: OpenAI organization ID.
-        project: OpenAI project ID.
-        default_headers: Additional HTTP headers to include in requests.
-        params: Input parameters for model configuration and behavior.
-        **kwargs: Additional arguments passed to the parent LLMService.
     """
 
     class InputParams(BaseModel):
@@ -101,8 +92,24 @@ class BaseOpenAILLMService(LLMService):
         project=None,
         default_headers: Optional[Mapping[str, str]] = None,
         params: Optional[InputParams] = None,
+        retry_timeout_secs: Optional[float] = 5.0,
+        retry_on_timeout: Optional[bool] = False,
         **kwargs,
     ):
+        """Initialize the BaseOpenAILLMService.
+
+        Args:
+            model: The OpenAI model name to use (e.g., "gpt-4.1", "gpt-4o").
+            api_key: OpenAI API key. If None, uses environment variable.
+            base_url: Custom base URL for OpenAI API. If None, uses default.
+            organization: OpenAI organization ID.
+            project: OpenAI project ID.
+            default_headers: Additional HTTP headers to include in requests.
+            params: Input parameters for model configuration and behavior.
+            retry_timeout_secs: Request timeout in seconds. Defaults to 5.0 seconds.
+            retry_on_timeout: Whether to retry the request once if it times out.
+            **kwargs: Additional arguments passed to the parent LLMService.
+        """
         super().__init__(**kwargs)
 
         params = params or BaseOpenAILLMService.InputParams()
@@ -117,6 +124,8 @@ class BaseOpenAILLMService(LLMService):
             "max_completion_tokens": params.max_completion_tokens,
             "extra": params.extra if isinstance(params.extra, dict) else {},
         }
+        self._retry_timeout_secs = retry_timeout_secs
+        self._retry_on_timeout = retry_on_timeout
         self.set_model_name(model)
         self._client = self.create_client(
             api_key=api_key,
@@ -173,7 +182,7 @@ class BaseOpenAILLMService(LLMService):
     async def get_chat_completions(
         self, context: OpenAILLMContext, messages: List[ChatCompletionMessageParam]
     ) -> AsyncStream[ChatCompletionChunk]:
-        """Get streaming chat completions from OpenAI API.
+        """Get streaming chat completions from OpenAI API with optional timeout and retry.
 
         Args:
             context: The LLM context containing tools and configuration.
@@ -182,6 +191,37 @@ class BaseOpenAILLMService(LLMService):
         Returns:
             Async stream of chat completion chunks.
         """
+        params = self.build_chat_completion_params(context, messages)
+
+        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")
+                chunks = await self._client.chat.completions.create(**params)
+                return chunks
+        else:
+            chunks = await self._client.chat.completions.create(**params)
+            return chunks
+
+    def build_chat_completion_params(
+        self, context: OpenAILLMContext, messages: List[ChatCompletionMessageParam]
+    ) -> dict:
+        """Build parameters for chat completion request.
+
+        Subclasses can override this to customize parameters for different providers.
+
+        Args:
+            context: The LLM context containing tools and configuration.
+            messages: List of chat completion messages to send.
+
+        Returns:
+            Dictionary of parameters for the chat completion request.
+        """
         params = {
             "model": self.model_name,
             "stream": True,
@@ -199,9 +239,7 @@ class BaseOpenAILLMService(LLMService):
         }
 
         params.update(self._settings["extra"])
-
-        chunks = await self._client.chat.completions.create(**params)
-        return chunks
+        return params
 
     async def _stream_chat_completions(
         self, context: OpenAILLMContext
@@ -245,7 +283,7 @@ class BaseOpenAILLMService(LLMService):
             context
         )
 
-        async for chunk in WatchdogAsyncIterator(chunk_stream, manager=self.task_manager):
+        async for chunk in chunk_stream:
             if chunk.usage:
                 tokens = LLMTokenUsage(
                     prompt_tokens=chunk.usage.prompt_tokens,

pipecat/services/openai/image.py

@@ -4,6 +4,12 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""OpenAI image generation service implementation.
+
+This module provides integration with OpenAI's DALL-E image generation API
+for creating images from text prompts.
+"""
+
 import io
 from typing import AsyncGenerator, Literal, Optional
 
@@ -21,6 +27,13 @@ from pipecat.services.image_service import ImageGenService
 
 
 class OpenAIImageGenService(ImageGenService):
+    """OpenAI DALL-E image generation service.
+
+    Provides image generation capabilities using OpenAI's DALL-E models.
+    Supports various image sizes and can generate images from text prompts
+    with configurable quality and style parameters.
+    """
+
     def __init__(
         self,
         *,
@@ -30,6 +43,15 @@ class OpenAIImageGenService(ImageGenService):
         image_size: Literal["256x256", "512x512", "1024x1024", "1792x1024", "1024x1792"],
         model: str = "dall-e-3",
     ):
+        """Initialize the OpenAI image generation service.
+
+        Args:
+            api_key: OpenAI API key for authentication.
+            base_url: Custom base URL for OpenAI API. If None, uses default.
+            aiohttp_session: HTTP session for downloading generated images.
+            image_size: Target size for generated images.
+            model: DALL-E model to use for generation. Defaults to "dall-e-3".
+        """
         super().__init__()
         self.set_model_name(model)
         self._image_size = image_size
@@ -37,6 +59,14 @@ class OpenAIImageGenService(ImageGenService):
         self._aiohttp_session = aiohttp_session
 
     async def run_image_gen(self, prompt: str) -> AsyncGenerator[Frame, None]:
+        """Generate an image from a text prompt using OpenAI's DALL-E.
+
+        Args:
+            prompt: Text description of the image to generate.
+
+        Yields:
+            Frame: URLImageRawFrame containing the generated image data.
+        """
         logger.debug(f"Generating image from prompt: {prompt}")
 
         image = await self._client.images.generate(

pipecat/services/openai/llm.py

@@ -61,11 +61,6 @@ class OpenAILLMService(BaseOpenAILLMService):
     Provides a complete OpenAI LLM service with context aggregation support.
     Uses the BaseOpenAILLMService for core functionality and adds OpenAI-specific
     context aggregator creation.
-
-    Args:
-        model: The OpenAI model name to use. Defaults to "gpt-4.1".
-        params: Input parameters for model configuration.
-        **kwargs: Additional arguments passed to the parent BaseOpenAILLMService.
     """
 
     def __init__(
@@ -75,6 +70,13 @@ class OpenAILLMService(BaseOpenAILLMService):
         params: Optional[BaseOpenAILLMService.InputParams] = None,
         **kwargs,
     ):
+        """Initialize OpenAI LLM service.
+
+        Args:
+            model: The OpenAI model name to use. Defaults to "gpt-4.1".
+            params: Input parameters for model configuration.
+            **kwargs: Additional arguments passed to the parent BaseOpenAILLMService.
+        """
         super().__init__(model=model, params=params, **kwargs)
 
     def create_context_aggregator(

pipecat/services/openai/stt.py

@@ -4,6 +4,8 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""OpenAI Speech-to-Text service implementation using OpenAI's transcription API."""
+
 from typing import Optional
 
 from pipecat.services.whisper.base_stt import BaseWhisperSTTService, Transcription
@@ -15,15 +17,6 @@ class OpenAISTTService(BaseWhisperSTTService):
 
     Uses OpenAI's transcription API to convert audio to text. Requires an OpenAI API key
     set via the api_key parameter or OPENAI_API_KEY environment variable.
-
-    Args:
-        model: Model to use — either gpt-4o or Whisper. Defaults to "gpt-4o-transcribe".
-        api_key: OpenAI API key. Defaults to None.
-        base_url: API base URL. Defaults to None.
-        language: Language of the audio input. Defaults to English.
-        prompt: Optional text to guide the model's style or continue a previous segment.
-        temperature: Optional sampling temperature between 0 and 1. Defaults to 0.0.
-        **kwargs: Additional arguments passed to BaseWhisperSTTService.
     """
 
     def __init__(
@@ -37,6 +30,17 @@ class OpenAISTTService(BaseWhisperSTTService):
         temperature: Optional[float] = None,
         **kwargs,
     ):
+        """Initialize OpenAI STT service.
+
+        Args:
+            model: Model to use — either gpt-4o or Whisper. Defaults to "gpt-4o-transcribe".
+            api_key: OpenAI API key. Defaults to None.
+            base_url: API base URL. Defaults to None.
+            language: Language of the audio input. Defaults to English.
+            prompt: Optional text to guide the model's style or continue a previous segment.
+            temperature: Optional sampling temperature between 0 and 1. Defaults to 0.0.
+            **kwargs: Additional arguments passed to BaseWhisperSTTService.
+        """
         super().__init__(
             model=model,
             api_key=api_key,

pipecat/services/openai/tts.py

@@ -4,6 +4,12 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
+"""OpenAI text-to-speech service implementation.
+
+This module provides integration with OpenAI's text-to-speech API for
+generating high-quality synthetic speech from text input.
+"""
+
 from typing import AsyncGenerator, Dict, Literal, Optional
 
 from loguru import logger
@@ -43,16 +49,8 @@ class OpenAITTSService(TTSService):
     """OpenAI Text-to-Speech service that generates audio from text.
 
     This service uses the OpenAI TTS API to generate PCM-encoded audio at 24kHz.
-
-    Args:
-        api_key: OpenAI API key. Defaults to None.
-        voice: Voice ID to use. Defaults to "alloy".
-        model: TTS model to use. Defaults to "gpt-4o-mini-tts".
-        sample_rate: Output audio sample rate in Hz. Defaults to None.
-        **kwargs: Additional keyword arguments passed to TTSService.
-
-    The service returns PCM-encoded audio at the specified sample rate.
-
+    Supports multiple voice models and configurable parameters for high-quality
+    speech synthesis with streaming audio output.
     """
 
     OPENAI_SAMPLE_RATE = 24000  # OpenAI TTS always outputs at 24kHz
@@ -68,6 +66,17 @@ class OpenAITTSService(TTSService):
         instructions: Optional[str] = None,
         **kwargs,
     ):
+        """Initialize OpenAI TTS service.
+
+        Args:
+            api_key: OpenAI API key for authentication. If None, uses environment variable.
+            base_url: Custom base URL for OpenAI API. If None, uses default.
+            voice: Voice ID to use for synthesis. Defaults to "alloy".
+            model: TTS model to use. Defaults to "gpt-4o-mini-tts".
+            sample_rate: Output audio sample rate in Hz. If None, uses OpenAI's default 24kHz.
+            instructions: Optional instructions to guide voice synthesis behavior.
+            **kwargs: Additional keyword arguments passed to TTSService.
+        """
         if sample_rate and sample_rate != self.OPENAI_SAMPLE_RATE:
             logger.warning(
                 f"OpenAI TTS only supports {self.OPENAI_SAMPLE_RATE}Hz sample rate. "
@@ -81,13 +90,28 @@ class OpenAITTSService(TTSService):
         self._client = AsyncOpenAI(api_key=api_key, base_url=base_url)
 
     def can_generate_metrics(self) -> bool:
+        """Check if this service can generate processing metrics.
+
+        Returns:
+            True, as OpenAI TTS service supports metrics generation.
+        """
         return True
 
     async def set_model(self, model: str):
+        """Set the TTS model to use.
+
+        Args:
+            model: The model name to use for text-to-speech synthesis.
+        """
         logger.info(f"Switching TTS model to: [{model}]")
         self.set_model_name(model)
 
     async def start(self, frame: StartFrame):
+        """Start the OpenAI TTS service.
+
+        Args:
+            frame: The start frame containing initialization parameters.
+        """
         await super().start(frame)
         if self.sample_rate != self.OPENAI_SAMPLE_RATE:
             logger.warning(
@@ -97,6 +121,14 @@ class OpenAITTSService(TTSService):
 
     @traced_tts
     async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
+        """Generate speech from text using OpenAI's TTS API.
+
+        Args:
+            text: The text to synthesize into speech.
+
+        Yields:
+            Frame: Audio frames containing the synthesized speech data.
+        """
         logger.debug(f"{self}: Generating TTS [{text}]")
         try:
             await self.start_ttfb_metrics()

pipecat/services/openai_realtime_beta/azure.py

@@ -11,7 +11,7 @@ from loguru import logger
 from .openai import OpenAIRealtimeBetaLLMService
 
 try:
-    import websockets
+    from websockets.asyncio.client import connect as websocket_connect
 except ModuleNotFoundError as e:
     logger.error(f"Exception: {e}")
     logger.error(
@@ -26,12 +26,6 @@ class AzureRealtimeBetaLLMService(OpenAIRealtimeBetaLLMService):
     Extends the OpenAI Realtime service to work with Azure OpenAI endpoints,
     using Azure's authentication headers and endpoint format. Provides the same
     real-time audio and text communication capabilities as the base OpenAI service.
-
-    Args:
-        api_key: The API key for the Azure OpenAI service.
-        base_url: The full Azure WebSocket endpoint URL including api-version and deployment.
-            Example: "wss://my-project.openai.azure.com/openai/realtime?api-version=2024-10-01-preview&deployment=my-realtime-deployment"
-        **kwargs: Additional arguments passed to parent OpenAIRealtimeBetaLLMService.
     """
 
     def __init__(
@@ -41,6 +35,14 @@ class AzureRealtimeBetaLLMService(OpenAIRealtimeBetaLLMService):
         base_url: str,
         **kwargs,
     ):
+        """Initialize Azure Realtime Beta LLM service.
+
+        Args:
+            api_key: The API key for the Azure OpenAI service.
+            base_url: The full Azure WebSocket endpoint URL including api-version and deployment.
+                Example: "wss://my-project.openai.azure.com/openai/realtime?api-version=2024-10-01-preview&deployment=my-realtime-deployment"
+            **kwargs: Additional arguments passed to parent OpenAIRealtimeBetaLLMService.
+        """
         super().__init__(base_url=base_url, api_key=api_key, **kwargs)
         self.api_key = api_key
         self.base_url = base_url
@@ -53,9 +55,9 @@ class AzureRealtimeBetaLLMService(OpenAIRealtimeBetaLLMService):
                 return
 
             logger.info(f"Connecting to {self.base_url}, api key: {self.api_key}")
-            self._websocket = await websockets.connect(
+            self._websocket = await websocket_connect(
                 uri=self.base_url,
-                extra_headers={
+                additional_headers={
                     "api-key": self.api_key,
                 },
             )

pipecat/services/openai_realtime_beta/context.py

@@ -37,14 +37,16 @@ class OpenAIRealtimeLLMContext(OpenAILLMContext):
     Extends the standard OpenAI LLM context to support real-time session properties,
     instruction management, and conversion between standard message formats and
     realtime conversation items.
-
-    Args:
-        messages: Initial conversation messages. Defaults to None.
-        tools: Available function tools. Defaults to None.
-        **kwargs: Additional arguments passed to parent OpenAILLMContext.
     """
 
     def __init__(self, messages=None, tools=None, **kwargs):
+        """Initialize the OpenAIRealtimeLLMContext.
+
+        Args:
+            messages: Initial conversation messages. Defaults to None.
+            tools: Available function tools. Defaults to None.
+            **kwargs: Additional arguments passed to parent OpenAILLMContext.
+        """
         super().__init__(messages=messages, tools=tools, **kwargs)
         self.__setup_local()
 

pipecat/services/openai_realtime_beta/events.py

@@ -18,13 +18,7 @@ from pydantic import BaseModel, ConfigDict, Field
 
 
 class InputAudioTranscription(BaseModel):
-    """Configuration for audio transcription settings.
-
-    Parameters:
-        model: Transcription model to use (e.g., "gpt-4o-transcribe", "whisper-1").
-        language: Optional language code for transcription.
-        prompt: Optional transcription hint text.
-    """
+    """Configuration for audio transcription settings."""
 
     model: str = "gpt-4o-transcribe"
     language: Optional[str]
@@ -36,6 +30,13 @@ class InputAudioTranscription(BaseModel):
         language: Optional[str] = None,
         prompt: Optional[str] = None,
     ):
+        """Initialize InputAudioTranscription.
+
+        Args:
+            model: Transcription model to use (e.g., "gpt-4o-transcribe", "whisper-1").
+            language: Optional language code for transcription.
+            prompt: Optional transcription hint text.
+        """
         super().__init__(model=model, language=language, prompt=prompt)
 
 
@@ -881,6 +882,8 @@ class TokenDetails(BaseModel):
     audio_tokens: Optional[int] = 0
 
     class Config:
+        """Pydantic configuration for TokenDetails."""
+
         extra = "allow"
 
 

pipecat/services/openai_realtime_beta/openai.py

@@ -53,7 +53,6 @@ from pipecat.processors.frame_processor import FrameDirection
 from pipecat.services.llm_service import FunctionCallFromLLM, LLMService
 from pipecat.services.openai.llm import OpenAIContextAggregatorPair
 from pipecat.transcriptions.language import Language
-from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 from pipecat.utils.time import time_now_iso8601
 from pipecat.utils.tracing.service_decorators import traced_openai_realtime, traced_stt
 
@@ -66,7 +65,7 @@ from .context import (
 from .frames import RealtimeFunctionCallResultFrame, RealtimeMessagesUpdateFrame
 
 try:
-    import websockets
+    from websockets.asyncio.client import connect as websocket_connect
 except ModuleNotFoundError as e:
     logger.error(f"Exception: {e}")
     logger.error("In order to use OpenAI, you need to `pip install pipecat-ai[openai]`.")
@@ -96,17 +95,6 @@ class OpenAIRealtimeBetaLLMService(LLMService):
     Implements the OpenAI Realtime API Beta with WebSocket communication for low-latency
     bidirectional audio and text interactions. Supports function calling, conversation
     management, and real-time transcription.
-
-    Args:
-        api_key: OpenAI API key for authentication.
-        model: OpenAI model name. Defaults to "gpt-4o-realtime-preview-2025-06-03".
-        base_url: WebSocket base URL for the realtime API.
-            Defaults to "wss://api.openai.com/v1/realtime".
-        session_properties: Configuration properties for the realtime session.
-            If None, uses default SessionProperties.
-        start_audio_paused: Whether to start with audio input paused. Defaults to False.
-        send_transcription_frames: Whether to emit transcription frames. Defaults to True.
-        **kwargs: Additional arguments passed to parent LLMService.
     """
 
     # Overriding the default adapter to use the OpenAIRealtimeLLMAdapter one.
@@ -123,6 +111,19 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         send_transcription_frames: bool = True,
         **kwargs,
     ):
+        """Initialize the OpenAI Realtime Beta LLM service.
+
+        Args:
+            api_key: OpenAI API key for authentication.
+            model: OpenAI model name. Defaults to "gpt-4o-realtime-preview-2025-06-03".
+            base_url: WebSocket base URL for the realtime API.
+                Defaults to "wss://api.openai.com/v1/realtime".
+            session_properties: Configuration properties for the realtime session.
+                If None, uses default SessionProperties.
+            start_audio_paused: Whether to start with audio input paused. Defaults to False.
+            send_transcription_frames: Whether to emit transcription frames. Defaults to True.
+            **kwargs: Additional arguments passed to parent LLMService.
+        """
         full_url = f"{base_url}?model={model}"
         super().__init__(base_url=full_url, **kwargs)
 
@@ -169,6 +170,15 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         """
         self._audio_input_paused = paused
 
+    def _is_modality_enabled(self, modality: str) -> bool:
+        """Check if a specific modality is enabled, "text" or "audio"."""
+        modalities = self._session_properties.modalities or ["audio", "text"]
+        return modality in modalities
+
+    def _get_enabled_modalities(self) -> list[str]:
+        """Get the list of enabled modalities."""
+        return self._session_properties.modalities or ["audio", "text"]
+
     async def retrieve_conversation_item(self, item_id: str):
         """Retrieve a conversation item by ID from the server.
 
@@ -241,7 +251,9 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         await self.stop_all_metrics()
         if self._current_assistant_response:
             await self.push_frame(LLMFullResponseEndFrame())
-            await self.push_frame(TTSStoppedFrame())
+            # Only push TTSStoppedFrame if audio modality is enabled
+            if self._is_modality_enabled("audio"):
+                await self.push_frame(TTSStoppedFrame())
 
     async def _handle_user_started_speaking(self, frame):
         pass
@@ -385,9 +397,9 @@ class OpenAIRealtimeBetaLLMService(LLMService):
                 # Here we assume that if we have a websocket, we are connected. We
                 # handle disconnections in the send/recv code paths.
                 return
-            self._websocket = await websockets.connect(
+            self._websocket = await websocket_connect(
                 uri=self.base_url,
-                extra_headers={
+                additional_headers={
                     "Authorization": f"Bearer {self.api_key}",
                     "OpenAI-Beta": "realtime=v1",
                 },
@@ -443,7 +455,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
     #
 
     async def _receive_task_handler(self):
-        async for message in WatchdogAsyncIterator(self._websocket, manager=self.task_manager):
+        async for message in self._websocket:
             evt = events.parse_server_event(message)
             if evt.type == "session.created":
                 await self._handle_evt_session_created(evt)
@@ -467,6 +479,8 @@ class OpenAIRealtimeBetaLLMService(LLMService):
                 await self._handle_evt_speech_started(evt)
             elif evt.type == "input_audio_buffer.speech_stopped":
                 await self._handle_evt_speech_stopped(evt)
+            elif evt.type == "response.text.delta":
+                await self._handle_evt_text_delta(evt)
             elif evt.type == "response.audio_transcript.delta":
                 await self._handle_evt_audio_transcript_delta(evt)
             elif evt.type == "error":
@@ -615,6 +629,10 @@ class OpenAIRealtimeBetaLLMService(LLMService):
             # Response message without preceding user message. Add it to the context.
             await self._handle_assistant_output(evt.response.output)
 
+    async def _handle_evt_text_delta(self, evt):
+        if evt.delta:
+            await self.push_frame(LLMTextFrame(evt.delta))
+
     async def _handle_evt_audio_transcript_delta(self, evt):
         if evt.delta:
             await self.push_frame(LLMTextFrame(evt.delta))
@@ -637,6 +655,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         """Maybe handle an error event related to retrieving a conversation item.
 
         If the given error event is an error retrieving a conversation item:
+
         - set an exception on the future that retrieve_conversation_item() is waiting on
         - return true
         Otherwise:
@@ -720,7 +739,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         await self.start_ttfb_metrics()
         await self.send_client_event(
             events.ResponseCreateEvent(
-                response=events.ResponseProperties(modalities=["audio", "text"])
+                response=events.ResponseProperties(modalities=self._get_enabled_modalities())
             )
         )