wip: stub conversation manager

src-tauri/Cargo.lock

···
 name = "miwiwi"
 version = "0.1.0"
 dependencies = [
+ "base64 0.22.1",
  "cpal",
  "dasp",
  "futures-util",

src-tauri/Cargo.toml

···
 ts-rs = "11.0.1"
 serde_string_enum = "0.2.1"
 unicase = "2.8.1"
+base64 = "0.22.1"
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-positioner = "2"

src-tauri/src/cartesia/tts.rs

···
     },
 }
 
+#[derive(Clone)]
 pub struct TtsContext {
     pub id: String,
-    reader: Mutex<UnboundedReceiver<TtsMessage>>,
+    pub reader: Arc<Mutex<UnboundedReceiver<TtsMessage>>>,
     writer: Arc<Mutex<UnboundedSender<TtsInputMessage>>>,
 }
 impl TtsContext {
-    async fn send(&self, content: String, is_final: bool) {
+    pub async fn send(&self, content: String, is_final: bool) {
         let id = self.id.clone();
         let tx = self.writer.lock().await;
 
···
         })
         .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 context_id: String,
+    pub content: String,
+    pub done: bool,
 }
 
 pub struct TtsManager {
···
         }
     }
 
-    async fn connect(&mut self) {
+    pub async fn connect(&mut self) {
         match &self.input {
             Some(_) => (),
             None => {
···
         }
     }
 
-    async fn new_context(&self, id: String) -> Result<TtsContext, ()> {
+    pub async fn new_context(&self, id: String) -> Result<TtsContext, ()> {
         match &self.input {
             Some(input) => {
                 let (tx_out, rx_out) = unbounded_channel::<TtsMessage>();
···
 
                 Ok(TtsContext {
                     id,
-                    reader: Mutex::new(rx_out),
+                    reader: Arc::new(Mutex::new(rx_out)),
                     writer: input.clone(),
                 })
             }

src-tauri/src/conversation/mod.rs

···
+use std::{io::Cursor, sync::Arc};
+
+use base64::prelude::{Engine as _, BASE64_STANDARD};
+use tauri::async_runtime::spawn;
+use tokio::sync::{
+    mpsc::{unbounded_channel, UnboundedReceiver},
+    Mutex, RwLock,
+};
+
+use crate::{
+    cartesia::tts::{TtsContext, TtsInputMessage, TtsManager, TtsMessage},
+    conversation::types::{Turn, TurnMessage},
+    letta::{
+        types::{LettaCompletionMessage, LettaMessageContent},
+        LettaManager,
+    },
+};
+
+mod types;
+
+pub struct ConversationManager {
+    turn: Option<Arc<RwLock<Turn>>>,
+    current_msg_index: RwLock<usize>,
+    letta_manager: Arc<LettaManager>,
+    tts_manager: Arc<TtsManager>,
+}
+impl ConversationManager {
+    pub fn new(letta_manager: Arc<LettaManager>, tts_manager: Arc<TtsManager>) -> Self {
+        Self {
+            turn: None,
+            current_msg_index: RwLock::new(0),
+            letta_manager,
+            tts_manager,
+        }
+    }
+
+    pub fn is_idle(&self) -> bool {
+        self.turn.is_none()
+    }
+
+    /// Start a new conversation turn
+    pub async fn start_turn(&mut self, prompt: String) {
+        if !self.is_idle() {
+            return;
+        };
+
+        let turn = Arc::new(RwLock::new(Turn::new()));
+
+        {
+            let mut idx = self.current_msg_index.write().await;
+
+            *idx = 0;
+            self.turn = Some(turn.clone());
+        }
+
+        spawn(handle_letta_messages(
+            prompt,
+            self.letta_manager.clone(),
+            self.tts_manager.clone(),
+            turn.clone(),
+        ));
+    }
+}
+
+async fn handle_letta_messages(
+    prompt: String,
+    letta: Arc<LettaManager>,
+    tts: Arc<TtsManager>,
+    turn: Arc<RwLock<Turn>>,
+) {
+    match letta.start_completion(prompt).await {
+        Ok(mut iter) => {
+            while let Some(msg) = iter.recv().await {
+                let turn = turn.read().await;
+
+                match turn.latest() {
+                    Some(latest) => match latest {
+                        TurnMessage::TextMessage {
+                            id,
+                            reader: _,
+                            writer,
+                        } if id == msg.id => {
+                            // Add current message to chunks
+                        }
+                        TurnMessage::AudioMessage {
+                            id,
+                            reader: _,
+                            writer,
+                            context,
+                            cursor: _,
+                            timestamps: _,
+                        } => {
+                            // Add current message to chunks
+                        }
+                    },
+                    None => {
+                        // Create a new message
+                        // Append message to chunks
+                    }
+                }
+            }
+        }
+        Err(err) => eprintln!("failed to start completion: {}", err),
+    }
+}
+
+async fn create_turn_message_from_letta(
+    src: LettaCompletionMessage,
+    tts: Arc<TtsManager>,
+) -> Option<TurnMessage> {
+    let (writer, reader) = unbounded_channel::<LettaCompletionMessage>();
+
+    writer.send(src.clone());
+
+    match src {
+        LettaCompletionMessage::ApprovalRequestMessage { id, .. }
+        | LettaCompletionMessage::ApprovalResponseMessage { id, .. }
+        | LettaCompletionMessage::HiddenReasoningMessage { id, .. }
+        | LettaCompletionMessage::SystemMessage { id, .. }
+        | LettaCompletionMessage::ToolCallMessage { id, .. }
+        | LettaCompletionMessage::ToolReturnMessage { id, .. } => {
+            Some(TurnMessage::TextMessage { id, reader, writer })
+        }
+        LettaCompletionMessage::AssistantMessage {
+            id,
+            content: blocks,
+            ..
+        } => {
+            let cursor = Cursor::new(Vec::new());
+            let mut content = "".to_owned();
+
+            for b in blocks {
+                match b {
+                    LettaMessageContent::Text { text } => content.push_str(&text),
+                    _ => (),
+                }
+            }
+
+            let context = tts
+                .new_context(id.clone())
+                .await
+                .expect("failed to create new TTS context");
+
+            context.send(content, false).await;
+
+            // Spawn task for handling audio generation
+            spawn((async |reader: Arc<
+                Mutex<UnboundedReceiver<TtsMessage>>,
+            >| {
+                // Listen to context and append to cursor
+                while let Some(msg) = reader.lock().await.recv().await {
+                    match msg {
+                        TtsMessage::Chunk { data, .. } => {
+                            // Decode chunk and write to cursor
+                            let out = BASE64_STANDARD.decode_vec(data, cursor.get_mut());
+                        }
+                        TtsMessage::Timestamps {
+                            word_timestamps, ..
+                        } => {
+                            // Append timestamps
+                        }
+                        _ => (),
+                    }
+                }
+            })(context.reader.clone()));
+
+            Some(TurnMessage::AudioMessage {
+                id: id.clone(),
+                reader,
+                writer,
+                context,
+                cursor,
+                timestamps: Vec::new(),
+            })
+        }
+        _ => None,
+    }
+}

src-tauri/src/conversation/types.rs

···
+use std::io::Cursor;
+
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+
+use crate::{
+    cartesia::tts::{TtsContext, TtsTimestamp},
+    letta::types::LettaCompletionMessage,
+};
+
+pub enum TurnMessage {
+    /// Represents a message to be displayed without audio
+    TextMessage {
+        id: String,
+        reader: UnboundedReceiver<LettaCompletionMessage>,
+        writer: UnboundedSender<LettaCompletionMessage>,
+    },
+
+    /// Represents a message with associated audio data
+    AudioMessage {
+        id: String,
+        reader: UnboundedReceiver<LettaCompletionMessage>,
+        writer: UnboundedSender<LettaCompletionMessage>,
+        context: TtsContext,
+        cursor: Cursor<Vec<u8>>,
+        timestamps: Vec<TtsTimestamp>,
+    },
+}
+
+pub struct Turn {
+    messages: Vec<TurnMessage>,
+    done: bool,
+}
+impl Turn {
+    pub fn new() -> Self {
+        Self {
+            messages: Vec::new(),
+            done: false,
+        }
+    }
+
+    pub fn complete(&mut self) {
+        self.done = true;
+    }
+
+    pub fn latest(&self) -> Option<&TurnMessage> {
+        self.messages.last()
+    }
+
+    pub fn add_message(&mut self, msg: TurnMessage) {
+        self.messages.push(msg);
+    }
+}

src-tauri/src/letta/types.rs

···
     name: String,
 }
 
-#[derive(Serialize, Deserialize, TS, Debug)]
+#[derive(Serialize, Deserialize, TS, Debug, Clone)]
 #[serde(tag = "type", rename_all = "lowercase")]
 pub enum LettaMessageContent {
     Text { text: String },
     Image { source: String },
 }
 
-#[derive(TS, Debug, SerializeLabeledStringEnum, DeserializeLabeledStringEnum)]
+#[derive(TS, Debug, SerializeLabeledStringEnum, DeserializeLabeledStringEnum, Clone, Copy)]
 pub enum LettaReasoningSource {
     #[string = "reasoner_model"]
     ReasonerModel,
···
     NonReasonerModel,
 }
 
-#[derive(SerializeLabeledStringEnum, DeserializeLabeledStringEnum, TS, Debug)]
+#[derive(SerializeLabeledStringEnum, DeserializeLabeledStringEnum, TS, Debug, Clone, Copy)]
 pub enum LettaHiddenReasoningState {
     #[string = "redacted"]
     Redacted,
···
     Omitted,
 }
 
-#[derive(Serialize, Deserialize, TS, Debug)]
+#[derive(Serialize, Deserialize, TS, Debug, Clone)]
 #[serde(untagged)]
 pub enum LettaToolCall {
     Call {
···
     },
 }
 
-#[derive(SerializeLabeledStringEnum, DeserializeLabeledStringEnum, TS, Debug)]
+#[derive(SerializeLabeledStringEnum, DeserializeLabeledStringEnum, TS, Debug, Clone, Copy)]
 pub enum LettaToolReturnStatus {
     #[string = "success"]
     Success,
···
     Error,
 }
 
-#[derive(Serialize, Deserialize, TS, Debug)]
+#[derive(Serialize, Deserialize, TS, Debug, Clone)]
 #[serde(tag = "message_type", rename_all = "snake_case")]
 #[ts(export)]
 pub enum LettaCompletionMessage {

src-tauri/src/lib.rs

···
 use tauri_plugin_window_state::{StateFlags, WindowExt as StateWindowExt};
 
 mod cartesia;
+mod conversation;
 mod devices;
 mod letta;
 mod secrets;