stub TTS manager

src-tauri/src/cartesia/client.rs

···
 
         stream
     }
+
+    pub async fn open_tts_connection(&self) -> WebSocketStream<MaybeTlsStream<TcpStream>> {
+        let mut request = Url::parse("wss://api.cartesia.ai/tts/websocket")
+            .expect("failed to parse TTS connection URL")
+            .as_str()
+            .into_client_request()
+            .expect("failed to instantiate TTS WebSocket request");
+
+        let headers = request.headers_mut();
+        let api_key = self
+            .secrets_manager
+            .get_secret(SecretName::CartesiaApiKey)
+            .expect("failed to retrieve API key");
+
+        headers.insert(
+            "X-API-Key",
+            HeaderValue::from_str(api_key.as_str()).expect("could not convert key to header value"),
+        );
+        headers.insert("Cartesia-Version", "2025-04-16".parse().unwrap());
+
+        let (stream, _) = connect_async(request)
+            .await
+            .expect("failed to open TTS websocket connection");
+
+        stream
+    }
 }

src-tauri/src/cartesia/mod.rs

···
 pub mod client;
 pub mod commands;
 pub mod stt;
+pub mod tts;

src-tauri/src/cartesia/tts.rs

···
+use std::{collections::HashMap, sync::Arc};
+
+use futures_util::{
+    stream::{SplitSink, SplitStream},
+    SinkExt, StreamExt,
+};
+use serde::{Deserialize, Serialize};
+use serde_json::{from_str, json};
+use tokio::{
+    net::TcpStream,
+    sync::{
+        mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
+        Mutex,
+    },
+};
+use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+use ts_rs::TS;
+use tungstenite::Message;
+
+use crate::cartesia::client::CartesiaClient;
+
+#[derive(Serialize, Deserialize, TS)]
+pub struct TtsTimestamp {
+    words: Vec<String>,
+    start: Vec<f32>,
+    end: Vec<f32>,
+}
+
+#[derive(Serialize, Deserialize, TS)]
+pub struct TtsPhonemeTimestamp {
+    phonemes: Vec<String>,
+    start: Vec<f32>,
+    end: Vec<f32>,
+}
+
+#[derive(Serialize, Deserialize, TS)]
+#[serde(tag = "type", rename_all = "snake_case")]
+#[ts(export)]
+pub enum TtsMessage {
+    Chunk {
+        data: String,
+        done: bool,
+        status_code: u16,
+        step_time: f32,
+        context_id: Option<String>,
+    },
+    FlushDone {
+        done: bool,
+        flush_done: bool,
+        flush_id: u16,
+        status_code: u16,
+        context_id: Option<String>,
+    },
+    Done {
+        done: bool,
+        status_code: u16,
+        context_id: Option<String>,
+    },
+    Timestamps {
+        done: bool,
+        status_code: u16,
+        context_id: Option<String>,
+        word_timestamps: Option<Vec<TtsTimestamp>>,
+    },
+    Error {
+        done: bool,
+        error: String,
+        status_code: u16,
+        context_id: Option<String>,
+    },
+    PhonemeTimestamps {
+        done: bool,
+        status_code: u16,
+        context_id: Option<String>,
+        phoneme_timestamps: Option<Vec<TtsPhonemeTimestamp>>,
+    },
+}
+
+pub struct TtsContext {
+    pub id: String,
+    reader: Mutex<UnboundedReceiver<TtsMessage>>,
+    writer: Arc<Mutex<UnboundedSender<TtsInputMessage>>>,
+}
+impl TtsContext {
+    async fn send(&self, content: String, is_final: bool) {
+        let id = self.id.clone();
+        let tx = self.writer.lock().await;
+
+        tx.send(TtsInputMessage {
+            context_id: id.clone(),
+            content,
+            done: is_final,
+        })
+        .expect(format!("failed to send content to context {id}").as_str())
+    }
+
+    async fn recv(&self) -> Option<TtsMessage> {
+        self.reader.lock().await.recv().await
+    }
+}
+
+#[derive(Serialize, Deserialize, TS)]
+#[ts(export)]
+pub struct TtsInputMessage {
+    context_id: String,
+    content: String,
+    done: bool,
+}
+
+pub struct TtsManager {
+    client: Arc<CartesiaClient>,
+    contexts: Arc<Mutex<HashMap<String, Arc<Mutex<UnboundedSender<TtsMessage>>>>>>,
+    input: Option<Arc<Mutex<UnboundedSender<TtsInputMessage>>>>,
+}
+impl TtsManager {
+    pub fn new(client: Arc<CartesiaClient>) -> Self {
+        Self {
+            client,
+            contexts: Arc::new(Mutex::new(HashMap::new().into())),
+            input: None,
+        }
+    }
+
+    async fn connect(&mut self) {
+        match &self.input {
+            Some(_) => (),
+            None => {
+                let stream = self.client.open_tts_connection().await;
+                let (tx_in, rx_in) = unbounded_channel::<TtsInputMessage>();
+                let (tx_ws, rx_ws) = stream.split();
+
+                tokio::spawn(handle_incoming(self.contexts.clone(), rx_ws));
+                tokio::spawn(handle_outgoing(tx_ws, rx_in));
+
+                self.input = Some(Arc::new(Mutex::new(tx_in)))
+            }
+        }
+    }
+
+    async fn new_context(&self, id: String) -> Result<TtsContext, ()> {
+        match &self.input {
+            Some(input) => {
+                let (tx_out, rx_out) = unbounded_channel::<TtsMessage>();
+
+                {
+                    let mut map = self.contexts.lock().await;
+                    map.insert(id.clone(), Arc::new(Mutex::new(tx_out)));
+                }
+
+                Ok(TtsContext {
+                    id,
+                    reader: Mutex::new(rx_out),
+                    writer: input.clone(),
+                })
+            }
+            None => {
+                todo!()
+            }
+        }
+    }
+}
+
+async fn handle_incoming(
+    contexts: Arc<Mutex<HashMap<String, Arc<Mutex<UnboundedSender<TtsMessage>>>>>>,
+    mut reader: SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>,
+) {
+    while let Some(event) = reader.next().await {
+        match event {
+            Ok(msg) => {
+                let text = msg.into_text().expect("failed to decode websocket message");
+
+                println!("Got message: {}", text);
+
+                match from_str::<TtsMessage>(&text).expect("failed to decode TTS message") {
+                    TtsMessage::Chunk {
+                        data,
+                        done,
+                        status_code,
+                        step_time,
+                        context_id: Some(id),
+                    } => match contexts.lock().await.get(&id) {
+                        Some(ctx) => {
+                            ctx.lock()
+                                .await
+                                .send(TtsMessage::Chunk {
+                                    data,
+                                    done,
+                                    status_code,
+                                    step_time,
+                                    context_id: Some(id),
+                                })
+                                .expect("failed to forward TTS chunk to contextual writer");
+                        }
+                        None => {
+                            eprintln!("no matching TTS sender context")
+                        }
+                    },
+                    _ => println!("got not chunk"),
+                }
+            }
+            Err(err) => {
+                eprintln!("got error from websocket: {}", err)
+            }
+        }
+    }
+}
+
+async fn handle_outgoing(
+    mut writer: SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>,
+    mut reader: UnboundedReceiver<TtsInputMessage>,
+) {
+    while let Some(msg) = reader.recv().await {
+        let payload = json!({
+            "model_id": "sonic-2",
+            "transcript": msg.content,
+            "voice": "TODO",
+            "output_format": {
+                "container": "raw",
+                "encoding": "pcm_f32le",
+                "sample_rate": 44100
+            },
+            "continue": msg.done,
+            "max_buffer_delay": 250,
+            "context_id": msg.context_id,
+        });
+
+        writer
+            .send(Message::Text(payload.to_string().into()))
+            .await
+            .expect("failed to send TTS generation request");
+    }
+}

src-tauri/src/state.rs

···
 use tauri_plugin_store::Store;
 
 use crate::{
-    cartesia::{client::CartesiaClient, stt::SttManager},
+    cartesia::{client::CartesiaClient, stt::SttManager, tts::TtsManager},
     devices::{input::InputDeviceManager, output::OutputDeviceManager, types::AudioDeviceError},
     letta::LettaManager,
     secrets::SecretsManager,
···
 pub struct AppState {
     pub cartesia_client: Arc<CartesiaClient>,
     pub stt_manager: Arc<SttManager>,
+    pub tts_manager: Arc<TtsManager>,
     pub letta_manager: Arc<LettaManager>,
     pub secrets_manager: Arc<SecretsManager>,
     pub input_device_manager: Arc<InputDeviceManager>,
···
             cartesia_client.clone(),
             input_device_manager.clone(),
         ));
+        let tts_manager = Arc::new(TtsManager::new(cartesia_client.clone()));
 
         Ok(AppState {
             input_device_manager,
···
             letta_manager,
             cartesia_client,
             stt_manager,
+            tts_manager,
         })
     }
 }