openai-dialog: Implement protocol specific ways to specify the voice

Author: pragmatrix

Cargo.toml

@@ -81,6 +81,7 @@ openai-api-rs = { workspace = true }
 serde_json = { workspace = true }
 chrono-tz = { version = "0.10.3" }
 url = { workspace = true }
+strum = { version = "0.28" }
 
 
 # For recognizing audio files in azure-transcribe.

examples/openai-dialog.rs

@@ -10,6 +10,7 @@ use std::{
 
 use anyhow::{Context, Result, bail};
 use chrono::Utc;
+use clap::builder::{PossibleValuesParser, TypedValueParser};
 use clap::{Parser, ValueEnum};
 use context_switch::{InputModality, OutputModality};
 use cpal::traits::{DeviceTrait, HostTrait, StreamTrait};
@@ -34,6 +35,8 @@ struct Cli {
     protocol: Option<CliProtocol>,
     #[arg(long)]
     endpoint: Option<String>,
+    #[arg(long, value_parser = realtime_voice_value_parser())]
+    voice: Option<types::RealtimeVoice>,
 }
 
 #[derive(Debug, Clone, Copy, ValueEnum)]
@@ -43,6 +46,19 @@ enum CliProtocol {
     Azure,
 }
 
+fn realtime_voice_value_parser() -> impl TypedValueParser<Value = types::RealtimeVoice> {
+    PossibleValuesParser::new(<types::RealtimeVoice as strum::VariantNames>::VARIANTS).try_map(
+        |value| {
+            parse_realtime_voice_value(&value)
+                .map_err(|e| format!("Invalid voice value `{value}`: {e}"))
+        },
+    )
+}
+
+fn parse_realtime_voice_value(value: &str) -> Result<types::RealtimeVoice, strum::ParseError> {
+    types::RealtimeVoice::from_str(value)
+}
+
 impl From<CliProtocol> for Protocol {
     fn from(value: CliProtocol) -> Self {
         match value {
@@ -107,6 +123,7 @@ async fn main() -> Result<()> {
         .or_else(|| env::var("OPENAI_REALTIME_ENDPOINT").ok())
         .filter(|endpoint| !endpoint.trim().is_empty());
     params.protocol = cli.protocol.map(Into::into);
+    params.voice = cli.voice;
     params.tools.push(get_time_function_definition());
 
     let (output_sender, output_receiver) = unbounded_channel();

external/openai-api-rs

@@ -352,18 +352,21 @@ impl Client {
             };
 
             if let Some(voice) = params.voice {
-                let mut audio = session.audio.unwrap_or(types::AudioConfig {
-                    input: None,
-                    output: None,
-                });
-                let mut output = audio.output.unwrap_or(types::AudioOutput {
-                    format: None,
-                    speed: 1.0,
-                    voice: None,
-                });
-                output.voice = Some(voice);
-                audio.output = Some(output);
-                session.audio = Some(audio);
+                match self.protocol {
+                    RealtimeProtocol::OpenAI => {
+                        session.voice = Some(voice);
+                    }
+                    RealtimeProtocol::Azure => {
+                        session.audio = Some(types::AudioConfig {
+                            input: None,
+                            output: Some(types::AudioOutput {
+                                format: None,
+                                speed: 1.0,
+                                voice: Some(voice),
+                            }),
+                        });
+                    }
+                }
                 send_update = true;
             }
 
@@ -554,17 +557,24 @@ impl Client {
                         tools,
                         tool_choice,
                     } => {
-                        let audio = voice.map(|voice| types::AudioConfig {
-                            input: None,
-                            output: Some(types::AudioOutput {
-                                format: None,
-                                speed: 1.0,
-                                voice: Some(voice),
-                            }),
-                        });
+                        let (voice, audio) = match self.protocol {
+                            RealtimeProtocol::OpenAI => (voice, None),
+                            RealtimeProtocol::Azure => {
+                                let audio = voice.map(|voice| types::AudioConfig {
+                                    input: None,
+                                    output: Some(types::AudioOutput {
+                                        format: None,
+                                        speed: 1.0,
+                                        voice: Some(voice),
+                                    }),
+                                });
+                                (None, audio)
+                            }
+                        };
 
                         let session = types::RealtimeSession {
                             instructions,
+                            voice,
                             audio,
                             tools,
                             tool_choice,