emit completion tokens to frontend

src-tauri/src/letta/commands.rs

···
+use tauri::ipc::Channel;
+
 use crate::{
-    letta::{LettaAgentInfo, LettaConfigKey},
+    letta::{types::LettaCompletionMessage, LettaAgentInfo, LettaConfigKey},
     state::AppState,
 };
 
 #[tauri::command]
 pub async fn list_agents(state: tauri::State<'_, AppState>) -> Result<Vec<LettaAgentInfo>, ()> {
-    Ok(state.letta_manager.list_agents().await)
+    match state.letta_manager.list_agents().await {
+        Ok(res) => Ok(res),
+        Err(err) => {
+            eprintln!("failed to list agents: {}", err);
+            Ok(Vec::new())
+        }
+    }
 }
 
 #[tauri::command]
···
 pub async fn start_llm_completion(
     state: tauri::State<'_, AppState>,
     message: String,
+    on_event: Channel<LettaCompletionMessage>,
 ) -> Result<(), ()> {
-    state.letta_manager.start_completion(message).await;
+    match state.letta_manager.start_completion(message).await {
+        Ok(mut rx) => {
+            while let Some(ev) = rx.recv().await {
+                on_event
+                    .send(ev)
+                    .expect("failed to forward event to channel");
+            }
 
-    Ok(())
+            Ok(())
+        }
+        Err(err) => {
+            eprintln!("failed to start completion: {}", err);
+
+            Ok(())
+        }
+    }
 }

src-tauri/src/letta/mod.rs

···
 use reqwest::Client;
 use reqwest_eventsource::{Event, EventSource};
 use serde_json::{from_str, json};
-use tauri::async_runtime::Mutex;
+use tauri::async_runtime::{channel, spawn, Mutex, Receiver, Sender};
 use tauri::Wry;
 use tauri_plugin_store::Store;
 
 use crate::secrets::SecretsManager;
-use types::{LettaAgentInfo, LettaCompletionMessage, LettaConfigKey};
+use types::{LettaAgentInfo, LettaCompletionMessage, LettaConfigKey, LettaError};
 
 pub mod commands;
 pub mod types;
···
         }
     }
 
-    pub async fn list_agents(&self) -> Vec<LettaAgentInfo> {
-        match self
+    pub async fn list_agents(&self) -> Result<Vec<LettaAgentInfo>, LettaError> {
+        let api_key = self
             .secrets_manager
-            .get_secret(crate::secrets::SecretName::LettaApiKey)
-        {
-            Ok(api_key) => {
-                let base_url = self.base_url.lock().await.to_owned();
-                let req = self
-                    .http_client
-                    .get(format!("{base_url}/v1/agents/"))
-                    .header("Authorization", format!("Bearer {api_key}"));
+            .get_secret(crate::secrets::SecretName::LettaApiKey)?;
+        let base_url = self.base_url.lock().await.to_owned();
+        let req = self
+            .http_client
+            .get(format!("{base_url}/v1/agents/"))
+            .header("Authorization", format!("Bearer {api_key}"));
 
-                let res = req.send().await.expect("failed to list Letta agents");
-                let out = res
-                    .json::<Vec<LettaAgentInfo>>()
-                    .await
-                    .expect("failed to deserialize agent info list");
+        let res = req.send().await.expect("failed to list Letta agents");
+        let out = res.json::<Vec<LettaAgentInfo>>().await?;
 
-                out
-            }
-            Err(_) => Vec::new(),
-        }
+        Ok(out)
     }
 
-    pub async fn start_completion(&self, msg: String) {
-        match self
+    pub async fn start_completion(
+        &self,
+        msg: String,
+    ) -> Result<Receiver<LettaCompletionMessage>, LettaError> {
+        let api_key = self
             .secrets_manager
-            .get_secret(crate::secrets::SecretName::LettaApiKey)
-        {
-            Ok(api_key) => {
-                let base_url = self.base_url.lock().await.to_owned();
-                let agent_id = self.agent_id.lock().await.to_owned();
-                let body = &json!({
-                    "messages": [
-                        {
-                            "role": "user",
-                            "content": [{
-                                "type": "text",
-                                "text": msg,
-                            }]
-                        }
-                    ],
-                    "stream_tokens": true
-                });
+            .get_secret(crate::secrets::SecretName::LettaApiKey)?;
+        let base_url = self.base_url.lock().await.to_owned();
+        let agent_id = self.agent_id.lock().await.to_owned();
+        let body = &json!({
+            "messages": [
+                {
+                    "role": "user",
+                    "content": [{
+                        "type": "text",
+                        "text": msg,
+                    }]
+                }
+            ],
+            "stream_tokens": true
+        });
+
+        println!("body: {:?}", body);
+
+        let req = self
+            .http_client
+            .post(format!("{base_url}/v1/agents/{agent_id}/messages/stream"))
+            .header("Authorization", format!("Bearer {api_key}"))
+            .header("Content-Type", "application/json")
+            .json(body);
+
+        let source = EventSource::new(req).expect("failed to clone request");
 
-                println!("body: {:?}", body);
+        let (tx, rx) = channel::<LettaCompletionMessage>(100);
+        let handler = handle_completion_messages(source, tx);
 
-                let req = self
-                    .http_client
-                    .post(format!("{base_url}/v1/agents/{agent_id}/messages/stream"))
-                    .header("Authorization", format!("Bearer {api_key}"))
-                    .header("Content-Type", "application/json")
-                    .json(body);
+        spawn(handler);
 
-                let mut source =
-                    EventSource::new(req).expect("could not convert request to event source");
+        return Ok(rx);
+    }
+}
 
-                while let Some(event) = source.next().await {
-                    match event {
-                        Ok(Event::Open) => println!("stream opened"),
-                        Ok(Event::Message(msg)) => {
-                            if msg.data == "[DONE]" {
-                                continue;
-                            };
+async fn handle_completion_messages(
+    mut source: EventSource,
+    sender: Sender<LettaCompletionMessage>,
+) {
+    while let Some(event) = source.next().await {
+        match event {
+            Ok(Event::Open) => println!("stream opened"),
+            Ok(Event::Message(msg)) => {
+                if msg.data == "[DONE]" {
+                    continue;
+                };
 
-                            match from_str::<LettaCompletionMessage>(&msg.data) {
-                                Ok(content) => {
-                                    println!("parsed content: {:?}", content)
-                                }
-                                Err(err) => {
-                                    eprintln!(
-                                        "failed to parse message: {:?}, err: {}",
-                                        msg.data.clone(),
-                                        err
-                                    )
-                                }
-                            }
-                        }
-                        Err(err) => {
-                            eprintln!("got stream error: {}", err);
-                            source.close();
-                        }
+                match from_str::<LettaCompletionMessage>(&msg.data) {
+                    Ok(content) => {
+                        sender.send(content).await.expect("failed to forward event");
+                    }
+                    Err(err) => {
+                        eprintln!(
+                            "failed to parse message: {:?}, err: {}",
+                            msg.data.clone(),
+                            err
+                        )
                     }
                 }
             }
-            Err(err) => eprintln!("could not fetch Letta API key: {}", err),
+            Err(err) => {
+                eprintln!("got stream error: {}", err);
+                source.close();
+            }
         }
     }
 }

src-tauri/src/letta/types.rs

···
+use core::fmt;
+
 use serde::{Deserialize, Serialize};
 use serde_string_enum::{DeserializeLabeledStringEnum, SerializeLabeledStringEnum};
 use strum::{Display, EnumString};
 use ts_rs::TS;
+
+#[derive(Debug)]
+pub enum LettaError {
+    ConfigurationError(String),
+    ApiKeyError(keyring::Error),
+    RequestError(reqwest::Error),
+    EventSourceError(reqwest_eventsource::Error),
+}
+
+impl fmt::Display for LettaError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LettaError::ConfigurationError(msg) => write!(f, "Configuration error: {}", msg),
+            LettaError::ApiKeyError(err) => write!(f, "API key error: {}", err),
+            LettaError::RequestError(err) => write!(f, "Letta request error: {}", err),
+            LettaError::EventSourceError(err) => write!(f, "Letta event source error: {}", err),
+        }
+    }
+}
+
+impl From<keyring::Error> for LettaError {
+    fn from(err: keyring::Error) -> Self {
+        LettaError::ApiKeyError(err)
+    }
+}
+
+impl From<reqwest::Error> for LettaError {
+    fn from(err: reqwest::Error) -> Self {
+        LettaError::RequestError(err)
+    }
+}
+
+impl From<reqwest_eventsource::Error> for LettaError {
+    fn from(err: reqwest_eventsource::Error) -> Self {
+        LettaError::EventSourceError(err)
+    }
+}
 
 #[derive(Serialize, Deserialize, Clone, Display, EnumString)]
 #[strum(prefix = "letta")]

src/lib/rust/LettaCompletionMessage.ts

···
 import type { LettaToolCall } from "./LettaToolCall";
 import type { LettaToolReturnStatus } from "./LettaToolReturnStatus";
 
-export type LettaCompletionMessage = { "message_type": "system_message", id: string, date: string, content: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "user_message", id: string, date: string, content: Array<LettaMessageContent>, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "reasoning_message", id: string, date: string, reasoning: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, source: LettaReasoningSource | null, signature: string | null, } | { "message_type": "hidden_reasoning_message", id: string, date: string, state: LettaHiddenReasoningState, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, hidden_reasoning: string | null, } | { "message_type": "tool_call_message", id: string, date: string, tool_call: LettaToolCall, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "tool_return_message", id: string, date: string, tool_return: string, status: LettaToolReturnStatus, tool_call_id: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, stdout: Array<string> | null, stderr: Array<string> | null, } | { "message_type": "assistant_message", id: string, date: string, content: Array<LettaMessageContent>, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "approval_request_message", id: string, date: string, tool_call: LettaToolCall, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "approval_response_message", id: string, date: string, approve: boolean, approval_request_id: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, reason: string | null, } | { "message_type": "stop_reason", stop_reason: string, } | { "message_type": "usage_statistics", completion_tokens: bigint, prompt_tokens: bigint, step_count: bigint, };
+export type LettaCompletionMessage =
+  | {
+      message_type: "system_message";
+      id: string;
+      date: string;
+      content: string;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+    }
+  | {
+      message_type: "user_message";
+      id: string;
+      date: string;
+      content: Array<LettaMessageContent>;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+    }
+  | {
+      message_type: "reasoning_message";
+      id: string;
+      date: string;
+      reasoning: string;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+      source: LettaReasoningSource | null;
+      signature: string | null;
+    }
+  | {
+      message_type: "hidden_reasoning_message";
+      id: string;
+      date: string;
+      state: LettaHiddenReasoningState;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+      hidden_reasoning: string | null;
+    }
+  | {
+      message_type: "tool_call_message";
+      id: string;
+      date: string;
+      tool_call: LettaToolCall;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+    }
+  | {
+      message_type: "tool_return_message";
+      id: string;
+      date: string;
+      tool_return: string;
+      status: LettaToolReturnStatus;
+      tool_call_id: string;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+      stdout: Array<string> | null;
+      stderr: Array<string> | null;
+    }
+  | {
+      message_type: "assistant_message";
+      id: string;
+      date: string;
+      content: Array<LettaMessageContent>;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+    }
+  | {
+      message_type: "approval_request_message";
+      id: string;
+      date: string;
+      tool_call: LettaToolCall;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+    }
+  | {
+      message_type: "approval_response_message";
+      id: string;
+      date: string;
+      approve: boolean;
+      approval_request_id: string;
+      name: string | null;
+      otid: string | null;
+      sender_id: string | null;
+      step_id: string | null;
+      is_err: boolean | null;
+      seq_id: bigint | null;
+      run_id: string | null;
+      reason: string | null;
+    }
+  | { message_type: "stop_reason"; stop_reason: string }
+  | {
+      message_type: "usage_statistics";
+      completion_tokens: bigint;
+      prompt_tokens: bigint;
+      step_count: bigint;
+    };

src/routes/+page.svelte

···
 <script lang="ts">
-    import { Channel, invoke } from "@tauri-apps/api/core";
+  import type { LettaCompletionMessage } from "$lib/rust/LettaCompletionMessage";
+  import { Channel, invoke } from "@tauri-apps/api/core";
   import { flip } from "svelte/animate";
   import { fade, fly } from "svelte/transition";
 
···
     }
   ] 
 
+  let placeholder = $state(textPlaceholder);
   let isRecording = $state(false);
   let isDrafting = $state(false);
-  let isCompleting = $state(false)
-  let placeholder = $state(textPlaceholder);
   let draft = $state("");
+  let isCompleting = $state(false)
+  let agentResponse = $state("")
   let history = $state(new Array<Message>());
 
   async function handleCompose() {
···
         isRecording = false;
       }
 
+      const onEvent = new Channel<LettaCompletionMessage>()
+
+      let lastType = ""
+      onEvent.onmessage = (e) => {
+        if (e.message_type !== lastType && agentResponse) {
+          let content = agentResponse
+
+          agentResponse = ""
+          lastType = e.message_type;
+
+          history.push({
+            id: crypto.randomUUID(),
+            from: "letta",
+            content
+          })
+        } else if (!lastType) {
+          lastType = e.message_type
+        }
+
+        switch (e.message_type) {
+          case "assistant_message":
+            agentResponse += e.content.map(c => c.type === "text" ? c.text : "").join("")
+            break;
+          case "reasoning_message":
+            agentResponse += e.reasoning
+            break;
+          default:
+            console.log("unsupported message:", e)
+        }
+      }
+
+      (async function () {
+        isCompleting = true;
+        await invoke("start_llm_completion", { message: draft, onEvent })
+        isCompleting = false;
+      })();
+
       const id = crypto.randomUUID();
-      invoke("start_llm_completion", { message: draft })
-
       history.push({ id, from: "user", content: draft })
 
       draft = ""
···
       </div>
     </div>
   {/each}
+
+  {#if agentResponse && history.length > 0}
+    <div
+      in:fly={{x: -20 }} 
+    class={[
+      "flex",
+      history[history.length - 1].from === "letta" ? "mt-1" : "mt-3",
+      "pr-6 justify-start",
+    ]}>
+      <div class={[
+          "py-3 px-4 rounded-t-xl leading-snug border border-rose-pine-muted/20",
+          "bg-rose-pine-base rounded-br-xl"
+        ]}
+      >
+        {agentResponse}
+      </div>
+    </div>
+  {/if}
 
   {#if isCompleting}
     <div class="flex">