@mastra/voice-openai 0.12.1 → 0.12.2

package/dist/docs/references/docs-voice-speech-to-text.md

@@ -15,26 +15,26 @@ To use STT in Mastra, you need to provide a `listeningModel` when initializing t
 ```typescript
 const voice = new OpenAIVoice({
   listeningModel: {
-    name: "whisper-1",
+    name: 'whisper-1',
     apiKey: process.env.OPENAI_API_KEY,
   },
-});
+})
 
 // If using default settings the configuration can be simplified to:
-const voice = new OpenAIVoice();
+const voice = new OpenAIVoice()
 ```
 
-## Available Providers
+## Available providers
 
 Mastra supports several Speech-to-Text providers, each with their own capabilities and strengths:
 
-- [**OpenAI**](https://mastra.ai/reference/voice/openai) - High-accuracy transcription with Whisper models
-- [**Azure**](https://mastra.ai/reference/voice/azure) - Microsoft's speech recognition with enterprise-grade reliability
-- [**ElevenLabs**](https://mastra.ai/reference/voice/elevenlabs) - Advanced speech recognition with support for multiple languages
-- [**Google**](https://mastra.ai/reference/voice/google) - Google's speech recognition with extensive language support
-- [**Cloudflare**](https://mastra.ai/reference/voice/cloudflare) - Edge-optimized speech recognition for low-latency applications
-- [**Deepgram**](https://mastra.ai/reference/voice/deepgram) - AI-powered speech recognition with high accuracy for various accents
-- [**Sarvam**](https://mastra.ai/reference/voice/sarvam) - Specialized in Indic languages and accents
+- [**OpenAI**](https://mastra.ai/reference/voice/openai): High-accuracy transcription with Whisper models
+- [**Azure**](https://mastra.ai/reference/voice/azure): Microsoft's speech recognition with enterprise-grade reliability
+- [**ElevenLabs**](https://mastra.ai/reference/voice/elevenlabs): Advanced speech recognition with support for multiple languages
+- [**Google**](https://mastra.ai/reference/voice/google): Google's speech recognition with extensive language support
+- [**Cloudflare**](https://mastra.ai/reference/voice/cloudflare): Edge-optimized speech recognition for low-latency applications
+- [**Deepgram**](https://mastra.ai/reference/voice/deepgram): AI-powered speech recognition with high accuracy for various accents
+- [**Sarvam**](https://mastra.ai/reference/voice/sarvam): Specialized in Indic languages and accents
 
 Each provider is implemented as a separate package that you can install as needed:
 
@@ -42,39 +42,38 @@ Each provider is implemented as a separate package that you can install as neede
 pnpm add @mastra/voice-openai@latest  # Example for OpenAI
 ```
 
-## Using the Listen Method
+## Using the listen method
 
 The primary method for STT is the `listen()` method, which converts spoken audio into text. Here's how to use it:
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { getMicrophoneStream } from "@mastra/node-audio";
+import { Agent } from '@mastra/core/agent'
+import { OpenAIVoice } from '@mastra/voice-openai'
+import { getMicrophoneStream } from '@mastra/node-audio'
 
-const voice = new OpenAIVoice();
+const voice = new OpenAIVoice()
 
 const agent = new Agent({
-  id: "voice-agent",
-  name: "Voice Agent",
-  instructions:
-    "You are a voice assistant that provides recommendations based on user input.",
-  model: "openai/gpt-5.1",
+  id: 'voice-agent',
+  name: 'Voice Agent',
+  instructions: 'You are a voice assistant that provides recommendations based on user input.',
+  model: 'openai/gpt-5.5',
   voice,
-});
+})
 
-const audioStream = getMicrophoneStream(); // Assume this function gets audio input
+const audioStream = getMicrophoneStream() // Assume this function gets audio input
 
 const transcript = await agent.voice.listen(audioStream, {
-  filetype: "m4a", // Optional: specify the audio file type
-});
+  filetype: 'm4a', // Optional: specify the audio file type
+})
 
-console.log(`User said: ${transcript}`);
+console.log(`User said: ${transcript}`)
 
 const { text } = await agent.generate(
   `Based on what the user said, provide them a recommendation: ${transcript}`,
-);
+)
 
-console.log(`Recommendation: ${text}`);
+console.log(`Recommendation: ${text}`)
 ```
 
 Check out the [Adding Voice to Agents](https://mastra.ai/docs/agents/adding-voice) documentation to learn how to use STT in an agent.

package/dist/docs/references/docs-voice-text-to-speech.md

@@ -19,30 +19,30 @@ The **`speaker`** option allows you to select different voices for speech synthe
 ```typescript
 const voice = new OpenAIVoice({
   speechModel: {
-    name: "tts-1-hd",
+    name: 'tts-1-hd',
     apiKey: process.env.OPENAI_API_KEY,
   },
-  speaker: "alloy",
-});
+  speaker: 'alloy',
+})
 
 // If using default settings the configuration can be simplified to:
-const voice = new OpenAIVoice();
+const voice = new OpenAIVoice()
 ```
 
-## Available Providers
+## Available providers
 
 Mastra supports a wide range of Text-to-Speech providers, each with their own unique capabilities and voice options. You can choose the provider that best suits your application's needs:
 
-- [**OpenAI**](https://mastra.ai/reference/voice/openai) - High-quality voices with natural intonation and expression
-- [**Azure**](https://mastra.ai/reference/voice/azure) - Microsoft's speech service with a wide range of voices and languages
-- [**ElevenLabs**](https://mastra.ai/reference/voice/elevenlabs) - Ultra-realistic voices with emotion and fine-grained control
-- [**PlayAI**](https://mastra.ai/reference/voice/playai) - Specialized in natural-sounding voices with various styles
-- [**Google**](https://mastra.ai/reference/voice/google) - Google's speech synthesis with multilingual support
-- [**Cloudflare**](https://mastra.ai/reference/voice/cloudflare) - Edge-optimized speech synthesis for low-latency applications
-- [**Deepgram**](https://mastra.ai/reference/voice/deepgram) - AI-powered speech technology with high accuracy
-- [**Speechify**](https://mastra.ai/reference/voice/speechify) - Text-to-speech optimized for readability and accessibility
-- [**Sarvam**](https://mastra.ai/reference/voice/sarvam) - Specialized in Indic languages and accents
-- [**Murf**](https://mastra.ai/reference/voice/murf) - Studio-quality voice overs with customizable parameters
+- [**OpenAI**](https://mastra.ai/reference/voice/openai): High-quality voices with natural intonation and expression
+- [**Azure**](https://mastra.ai/reference/voice/azure): Microsoft's speech service with a wide range of voices and languages
+- [**ElevenLabs**](https://mastra.ai/reference/voice/elevenlabs): Ultra-realistic voices with emotion and fine-grained control
+- [**PlayAI**](https://mastra.ai/reference/voice/playai): Specialized in natural-sounding voices with various styles
+- [**Google**](https://mastra.ai/reference/voice/google): Google's speech synthesis with multilingual support
+- [**Cloudflare**](https://mastra.ai/reference/voice/cloudflare): Edge-optimized speech synthesis for low-latency applications
+- [**Deepgram**](https://mastra.ai/reference/voice/deepgram): AI-powered speech technology with high accuracy
+- [**Speechify**](https://mastra.ai/reference/voice/speechify): Text-to-speech optimized for readability and accessibility
+- [**Sarvam**](https://mastra.ai/reference/voice/sarvam): Specialized in Indic languages and accents
+- [**Murf**](https://mastra.ai/reference/voice/murf): Studio-quality voice overs with customizable parameters
 
 Each provider is implemented as a separate package that you can install as needed:
 
@@ -50,35 +50,34 @@ Each provider is implemented as a separate package that you can install as neede
 pnpm add @mastra/voice-openai@latest  # Example for OpenAI
 ```
 
-## Using the Speak Method
+## Using the speak method
 
 The primary method for TTS is the `speak()` method, which converts text to speech. This method can accept options that allows you to specify the speaker and other provider-specific options. Here's how to use it:
 
 ```typescript
-import { Agent } from "@mastra/core/agent";
-import { OpenAIVoice } from "@mastra/voice-openai";
+import { Agent } from '@mastra/core/agent'
+import { OpenAIVoice } from '@mastra/voice-openai'
 
-const voice = new OpenAIVoice();
+const voice = new OpenAIVoice()
 
 const agent = new Agent({
-  id: "voice-agent",
-  name: "Voice Agent",
-  instructions:
-    "You are a voice assistant that can help users with their tasks.",
-  model: "openai/gpt-5.1",
+  id: 'voice-agent',
+  name: 'Voice Agent',
+  instructions: 'You are a voice assistant that can help users with their tasks.',
+  model: 'openai/gpt-5.5',
   voice,
-});
+})
 
-const { text } = await agent.generate("What color is the sky?");
+const { text } = await agent.generate('What color is the sky?')
 
 // Convert text to speech to an Audio Stream
 const readableStream = await voice.speak(text, {
-  speaker: "default", // Optional: specify a speaker
+  speaker: 'default', // Optional: specify a speaker
   properties: {
     speed: 1.0, // Optional: adjust speech speed
-    pitch: "default", // Optional: specify pitch if supported
+    pitch: 'default', // Optional: specify pitch if supported
   },
-});
+})
 ```
 
 Check out the [Adding Voice to Agents](https://mastra.ai/docs/agents/adding-voice) documentation to learn how to use TTS in an agent.

package/dist/docs/references/reference-voice-composite-voice.md

@@ -4,25 +4,25 @@ The CompositeVoice class allows you to combine different voice providers for tex
 
 CompositeVoice supports both Mastra voice providers and AI SDK model providers
 
-## Constructor Parameters
+## Constructor parameters
 
-**config:** (`object`): Configuration object for the composite voice service
+**config** (`object`): Configuration object for the composite voice service
 
-**config.input?:** (`MastraVoice | TranscriptionModel`): Voice provider or AI SDK transcription model to use for speech-to-text operations. AI SDK models are automatically wrapped.
+**config.input** (`MastraVoice | TranscriptionModel`): Voice provider or AI SDK transcription model to use for speech-to-text operations. AI SDK models are automatically wrapped.
 
-**config.output?:** (`MastraVoice | SpeechModel`): Voice provider or AI SDK speech model to use for text-to-speech operations. AI SDK models are automatically wrapped.
+**config.output** (`MastraVoice | SpeechModel`): Voice provider or AI SDK speech model to use for text-to-speech operations. AI SDK models are automatically wrapped.
 
-**config.realtime?:** (`MastraVoice`): Voice provider to use for real-time speech-to-speech operations
+**config.realtime** (`MastraVoice`): Voice provider to use for real-time speech-to-speech operations
 
 ## Methods
 
-### speak()
+### `speak()`
 
 Converts text to speech using the configured speaking provider.
 
-**input:** (`string | NodeJS.ReadableStream`): Text to convert to speech
+**input** (`string | NodeJS.ReadableStream`): Text to convert to speech
 
-**options?:** (`object`): Provider-specific options passed to the speaking provider
+**options** (`object`): Provider-specific options passed to the speaking provider
 
 Notes:
 
@@ -30,13 +30,13 @@ Notes:
 - Options are passed through to the configured speaking provider
 - Returns a stream of audio data
 
-### listen()
+### `listen()`
 
 Converts speech to text using the configured listening provider.
 
-**audioStream:** (`NodeJS.ReadableStream`): Audio stream to convert to text
+**audioStream** (`NodeJS.ReadableStream`): Audio stream to convert to text
 
-**options?:** (`object`): Provider-specific options passed to the listening provider
+**options** (`object`): Provider-specific options passed to the listening provider
 
 Notes:
 
@@ -44,13 +44,13 @@ Notes:
 - Options are passed through to the configured listening provider
 - Returns either a string or a stream of transcribed text, depending on the provider
 
-### getSpeakers()
+### `getSpeakers()`
 
 Returns a list of available voices from the speaking provider, where each node contains:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**key?:** (`value`): Additional voice properties that vary by provider (e.g., name, language)
+**key** (`value`): Additional voice properties that vary by provider (e.g., name, language)
 
 Notes:
 
@@ -59,30 +59,30 @@ Notes:
 - Each voice object will have at least a voiceId property
 - Additional voice properties depend on the speaking provider
 
-## Usage Examples
+## Usage examples
 
 ### Using Mastra Voice Providers
 
 ```typescript
-import { CompositeVoice } from "@mastra/core/voice";
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { PlayAIVoice } from "@mastra/voice-playai";
+import { CompositeVoice } from '@mastra/core/voice'
+import { OpenAIVoice } from '@mastra/voice-openai'
+import { PlayAIVoice } from '@mastra/voice-playai'
 
 // Create voice providers
-const openai = new OpenAIVoice();
-const playai = new PlayAIVoice();
+const openai = new OpenAIVoice()
+const playai = new PlayAIVoice()
 
 // Use OpenAI for listening (speech-to-text) and PlayAI for speaking (text-to-speech)
 const voice = new CompositeVoice({
   input: openai,
   output: playai,
-});
+})
 
 // Convert speech to text using OpenAI
-const text = await voice.listen(audioStream);
+const text = await voice.listen(audioStream)
 
 // Convert text to speech using PlayAI
-const audio = await voice.speak("Hello, world!");
+const audio = await voice.speak('Hello, world!')
 ```
 
 ### Using AI SDK Model Providers
@@ -90,19 +90,19 @@ const audio = await voice.speak("Hello, world!");
 You can pass AI SDK transcription and speech models directly to CompositeVoice:
 
 ```typescript
-import { CompositeVoice } from "@mastra/core/voice";
-import { openai } from "@ai-sdk/openai";
-import { elevenlabs } from "@ai-sdk/elevenlabs";
+import { CompositeVoice } from '@mastra/core/voice'
+import { openai } from '@ai-sdk/openai'
+import { elevenlabs } from '@ai-sdk/elevenlabs'
 
 // Use AI SDK models directly - they will be auto-wrapped
 const voice = new CompositeVoice({
-  input: openai.transcription('whisper-1'),      // AI SDK transcription
-  output: elevenlabs.speech('eleven_turbo_v2'),  // AI SDK speech
-});
+  input: openai.transcription('whisper-1'), // AI SDK transcription
+  output: elevenlabs.speech('eleven_turbo_v2'), // AI SDK speech
+})
 
 // Works the same way as with Mastra providers
-const text = await voice.listen(audioStream);
-const audio = await voice.speak("Hello from AI SDK!");
+const text = await voice.listen(audioStream)
+const audio = await voice.speak('Hello from AI SDK!')
 ```
 
 ### Mix and Match
@@ -110,12 +110,12 @@ const audio = await voice.speak("Hello from AI SDK!");
 You can combine Mastra providers with AI SDK models:
 
 ```typescript
-import { CompositeVoice } from "@mastra/core/voice";
-import { PlayAIVoice } from "@mastra/voice-playai";
-import { groq } from "@ai-sdk/groq";
+import { CompositeVoice } from '@mastra/core/voice'
+import { PlayAIVoice } from '@mastra/voice-playai'
+import { groq } from '@ai-sdk/groq'
 
 const voice = new CompositeVoice({
-  input: groq.transcription('whisper-large-v3'),  // AI SDK for STT
-  output: new PlayAIVoice(),                       // Mastra for TTS
-});
+  input: groq.transcription('whisper-large-v3'), // AI SDK for STT
+  output: new PlayAIVoice(), // Mastra for TTS
+})
 ```

package/dist/docs/references/reference-voice-openai.md

@@ -2,84 +2,90 @@
 
 The OpenAIVoice class in Mastra provides text-to-speech and speech-to-text capabilities using OpenAI's models.
 
-## Usage Example
+## Usage example
 
 ```typescript
-import { OpenAIVoice } from "@mastra/voice-openai";
+import { OpenAIVoice } from '@mastra/voice-openai'
 
 // Initialize with default configuration using environment variables
-const voice = new OpenAIVoice();
+const voice = new OpenAIVoice()
 
 // Or initialize with specific configuration
 const voiceWithConfig = new OpenAIVoice({
   speechModel: {
-    name: "tts-1-hd",
-    apiKey: "your-openai-api-key",
+    name: 'tts-1-hd',
+    apiKey: 'your-openai-api-key',
   },
   listeningModel: {
-    name: "whisper-1",
-    apiKey: "your-openai-api-key",
+    name: 'whisper-1',
+    apiKey: 'your-openai-api-key',
   },
-  speaker: "alloy", // Default voice
-});
+  speaker: 'alloy', // Default voice
+})
 
 // Convert text to speech
-const audioStream = await voice.speak("Hello, how can I help you?", {
-  speaker: "nova", // Override default voice
+const audioStream = await voice.speak('Hello, how can I help you?', {
+  speaker: 'nova', // Override default voice
   speed: 1.2, // Adjust speech speed
-});
+})
 
 // Convert speech to text
 const text = await voice.listen(audioStream, {
-  filetype: "mp3",
-});
+  filetype: 'mp3',
+})
 ```
 
 ## Configuration
 
-### Constructor Options
+### Constructor options
 
-**speechModel?:** (`OpenAIConfig`): Configuration for text-to-speech synthesis. (Default: `{ name: 'tts-1' }`)
+**speechModel** (`OpenAIConfig`): Configuration for text-to-speech synthesis. (Default: `{ name: 'tts-1' }`)
 
-**listeningModel?:** (`OpenAIConfig`): Configuration for speech-to-text recognition. (Default: `{ name: 'whisper-1' }`)
+**speechModel.name** (`'tts-1' | 'tts-1-hd' | 'whisper-1'`): Model name. Use 'tts-1-hd' for higher quality audio.
 
-**speaker?:** (`OpenAIVoiceId`): Default voice ID for speech synthesis. (Default: `'alloy'`)
+**speechModel.apiKey** (`string`): OpenAI API key. Falls back to OPENAI\_API\_KEY environment variable.
 
-### OpenAIConfig
+**listeningModel** (`OpenAIConfig`): Configuration for speech-to-text recognition. (Default: `{ name: 'whisper-1' }`)
 
-**name?:** (`'tts-1' | 'tts-1-hd' | 'whisper-1'`): Model name. Use 'tts-1-hd' for higher quality audio.
+**listeningModel.name** (`'tts-1' | 'tts-1-hd' | 'whisper-1'`): Model name. Use 'tts-1-hd' for higher quality audio.
 
-**apiKey?:** (`string`): OpenAI API key. Falls back to OPENAI\_API\_KEY environment variable.
+**listeningModel.apiKey** (`string`): OpenAI API key. Falls back to OPENAI\_API\_KEY environment variable.
+
+**speaker** (`OpenAIVoiceId`): Default voice ID for speech synthesis. (Default: `'alloy'`)
 
 ## Methods
 
-### speak()
+### `speak()`
 
 Converts text to speech using OpenAI's text-to-speech models.
 
-**input:** (`string | NodeJS.ReadableStream`): Text or text stream to convert to speech.
+**input** (`string | NodeJS.ReadableStream`): Text or text stream to convert to speech.
+
+**options** (`Options`): Configuration options.
 
-**options.speaker?:** (`OpenAIVoiceId`): Voice ID to use for speech synthesis. (Default: `Constructor's speaker value`)
+**options.speaker** (`OpenAIVoiceId`): Voice ID to use for speech synthesis.
 
-**options.speed?:** (`number`): Speech speed multiplier. (Default: `1.0`)
+**options.speed** (`number`): Speech speed multiplier.
 
 Returns: `Promise<NodeJS.ReadableStream>`
 
-### listen()
+### `listen()`
 
 Transcribes audio using OpenAI's Whisper model.
 
-**audioStream:** (`NodeJS.ReadableStream`): Audio stream to transcribe.
+**audioStream** (`NodeJS.ReadableStream`): Audio stream to transcribe.
+
+**options** (`Options`): Configuration options.
 
-**options.filetype?:** (`string`): Audio format of the input stream. (Default: `'mp3'`)
+**options.filetype** (`string`): Audio format of the input stream.
 
 Returns: `Promise<string>`
 
-### getSpeakers()
+### `getSpeakers()`
 
 Returns an array of available voice options, where each node contains:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
 ## Notes
 

package/dist/docs/references/reference-voice-voice.getSpeakers.md

@@ -2,123 +2,123 @@
 
 The `getSpeakers()` method retrieves a list of available voice options (speakers) from the voice provider. This allows applications to present users with voice choices or programmatically select the most appropriate voice for different contexts.
 
-## Usage Example
+## Usage example
 
 ```typescript
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { ElevenLabsVoice } from "@mastra/voice-elevenlabs";
+import { OpenAIVoice } from '@mastra/voice-openai'
+import { ElevenLabsVoice } from '@mastra/voice-elevenlabs'
 
 // Initialize voice providers
-const openaiVoice = new OpenAIVoice();
+const openaiVoice = new OpenAIVoice()
 const elevenLabsVoice = new ElevenLabsVoice({
   apiKey: process.env.ELEVENLABS_API_KEY,
-});
+})
 
 // Get available speakers from OpenAI
-const openaiSpeakers = await openaiVoice.getSpeakers();
-console.log("OpenAI voices:", openaiSpeakers);
+const openaiSpeakers = await openaiVoice.getSpeakers()
+console.log('OpenAI voices:', openaiSpeakers)
 // Example output: [{ voiceId: "alloy" }, { voiceId: "echo" }, { voiceId: "fable" }, ...]
 
 // Get available speakers from ElevenLabs
-const elevenLabsSpeakers = await elevenLabsVoice.getSpeakers();
-console.log("ElevenLabs voices:", elevenLabsSpeakers);
+const elevenLabsSpeakers = await elevenLabsVoice.getSpeakers()
+console.log('ElevenLabs voices:', elevenLabsSpeakers)
 // Example output: [{ voiceId: "21m00Tcm4TlvDq8ikWAM", name: "Rachel" }, ...]
 
 // Use a specific voice for speech
-const text = "Hello, this is a test of different voices.";
-await openaiVoice.speak(text, { speaker: openaiSpeakers[2].voiceId });
-await elevenLabsVoice.speak(text, { speaker: elevenLabsSpeakers[0].voiceId });
+const text = 'Hello, this is a test of different voices.'
+await openaiVoice.speak(text, { speaker: openaiSpeakers[2].voiceId })
+await elevenLabsVoice.speak(text, { speaker: elevenLabsSpeakers[0].voiceId })
 ```
 
 ## Parameters
 
-This method does not accept any parameters.
+This method doesn't accept any parameters.
 
-## Return Value
+## Return value
 
-**Promise\<Array<{ voiceId: string } & TSpeakerMetadata>>:** (`Promise`): A promise that resolves to an array of voice options, where each option contains at least a voiceId property and may include additional provider-specific metadata.
+**Promise\<Array<{ voiceId: string } & TSpeakerMetadata>>** (`Promise`): A promise that resolves to an array of voice options, where each option contains at least a voiceId property and may include additional provider-specific metadata.
 
-## Provider-Specific Metadata
+## Provider-specific metadata
 
 Different voice providers return different metadata for their voices:
 
 **OpenAI**:
 
-**voiceId:** (`string`): Unique identifier for the voice (e.g., 'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer')
+**voiceId** (`string`): Unique identifier for the voice (e.g., 'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer')
 
 **OpenAI Realtime**:
 
-**voiceId:** (`string`): Unique identifier for the voice (e.g., 'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer')
+**voiceId** (`string`): Unique identifier for the voice (e.g., 'alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer')
 
 **Deepgram**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**language:** (`string`): Language code embedded in the voice ID (e.g., 'en')
+**language** (`string`): Language code embedded in the voice ID (e.g., 'en')
 
 **ElevenLabs**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**name:** (`string`): Human-readable name of the voice
+**name** (`string`): Human-readable name of the voice
 
-**category:** (`string`): Category of the voice (e.g., 'premade', 'cloned')
+**category** (`string`): Category of the voice (e.g., 'premade', 'cloned')
 
 **Google**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**languageCodes:** (`string[]`): Array of language codes supported by the voice (e.g., \['en-US'])
+**languageCodes** (`string[]`): Array of language codes supported by the voice (e.g., \['en-US'])
 
 **Azure**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**language:** (`string`): Language code extracted from the voice ID (e.g., 'en')
+**language** (`string`): Language code extracted from the voice ID (e.g., 'en')
 
-**region:** (`string`): Region code extracted from the voice ID (e.g., 'US')
+**region** (`string`): Region code extracted from the voice ID (e.g., 'US')
 
 **Murf**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**name:** (`string`): Name of the voice (same as voiceId)
+**name** (`string`): Name of the voice (same as voiceId)
 
-**language:** (`string`): Language code extracted from the voice ID (e.g., 'en')
+**language** (`string`): Language code extracted from the voice ID (e.g., 'en')
 
-**gender:** (`string`): Gender of the voice (always 'neutral' in current implementation)
+**gender** (`string`): Gender of the voice (always 'neutral' in current implementation)
 
 **PlayAI**:
 
-**voiceId:** (`string`): Unique identifier for the voice (S3 URL to manifest.json)
+**voiceId** (`string`): Unique identifier for the voice (S3 URL to manifest.json)
 
-**name:** (`string`): Human-readable name of the voice (e.g., 'Angelo', 'Arsenio')
+**name** (`string`): Human-readable name of the voice (e.g., 'Angelo', 'Arsenio')
 
-**accent:** (`string`): Accent of the voice (e.g., 'US', 'Irish', 'US African American')
+**accent** (`string`): Accent of the voice (e.g., 'US', 'Irish', 'US African American')
 
-**gender:** (`string`): Gender of the voice ('M' or 'F')
+**gender** (`string`): Gender of the voice ('M' or 'F')
 
-**age:** (`string`): Age category of the voice (e.g., 'Young', 'Middle')
+**age** (`string`): Age category of the voice (e.g., 'Young', 'Middle')
 
-**style:** (`string`): Speaking style of the voice (e.g., 'Conversational')
+**style** (`string`): Speaking style of the voice (e.g., 'Conversational')
 
 **Speechify**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**name:** (`string`): Human-readable name of the voice
+**name** (`string`): Human-readable name of the voice
 
-**language:** (`string`): Language code of the voice (e.g., 'en-US')
+**language** (`string`): Language code of the voice (e.g., 'en-US')
 
 **Sarvam**:
 
-**voiceId:** (`string`): Unique identifier for the voice
+**voiceId** (`string`): Unique identifier for the voice
 
-**name:** (`string`): Human-readable name of the voice
+**name** (`string`): Human-readable name of the voice
 
-**language:** (`string`): Language of the voice (e.g., 'english', 'hindi')
+**language** (`string`): Language of the voice (e.g., 'english', 'hindi')
 
-**gender:** (`string`): Gender of the voice ('male' or 'female')
+**gender** (`string`): Gender of the voice ('male' or 'female')
 
 ## Notes