feat(listener): add loading state events for better UI feedback

Add new SessionEvent variants to provide visibility into the connection
and initialization phases between 'start listening' and 'got first transcript':

- InitializingAudio: emitted when SourceActor starts audio initialization
- AudioReady: emitted after audio streams are successfully set up
- Connecting: emitted when ListenerActor starts WebSocket connection
- Connected: emitted after successful WebSocket connection
- ConnectionError: emitted when connection fails (with error details)

These events allow the UI to show appropriate loading states during the
1-8 second window that was previously a blind spot.

Co-Authored-By: yujonglee <[email protected]>

Author: devin-ai-integration[bot]

plugins/listener/src/actors/listener.rs

@@ -88,8 +88,24 @@ impl Actor for ListenerActor {
         myself: ActorRef<Self::Msg>,
         args: Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
+        if let Err(error) = (SessionEvent::Connecting {
+            session_id: args.session_id.clone(),
+        })
+        .emit(&args.app)
+        {
+            tracing::error!(?error, "failed_to_emit_connecting");
+        }
+
         let (tx, rx_task, shutdown_tx) = spawn_rx_task(args.clone(), myself).await?;
 
+        if let Err(error) = (SessionEvent::Connected {
+            session_id: args.session_id.clone(),
+        })
+        .emit(&args.app)
+        {
+            tracing::error!(?error, "failed_to_emit_connected");
+        }
+
         let state = ListenerState {
             args,
             tx,
@@ -311,10 +327,22 @@ async fn spawn_rx_task_single_with_adapter<A: RealtimeSttAdapter>(
                 timeout_secs = LISTEN_CONNECT_TIMEOUT.as_secs_f32(),
                 "listen_ws_connect_timeout(single)"
             );
+            let _ = (SessionEvent::ConnectionError {
+                session_id: args.session_id.clone(),
+                error: "listen_ws_connect_timeout".to_string(),
+                retry_count: 0,
+            })
+            .emit(&args.app);
             return Err(actor_error("listen_ws_connect_timeout"));
         }
         Ok(Err(e)) => {
             tracing::error!(error = ?e, "listen_ws_connect_failed(single)");
+            let _ = (SessionEvent::ConnectionError {
+                session_id: args.session_id.clone(),
+                error: format!("listen_ws_connect_failed: {:?}", e),
+                retry_count: 0,
+            })
+            .emit(&args.app);
             return Err(actor_error(format!("listen_ws_connect_failed: {:?}", e)));
         }
         Ok(Ok(res)) => res,
@@ -371,10 +399,22 @@ async fn spawn_rx_task_dual_with_adapter<A: RealtimeSttAdapter>(
                 timeout_secs = LISTEN_CONNECT_TIMEOUT.as_secs_f32(),
                 "listen_ws_connect_timeout(dual)"
             );
+            let _ = (SessionEvent::ConnectionError {
+                session_id: args.session_id.clone(),
+                error: "listen_ws_connect_timeout".to_string(),
+                retry_count: 0,
+            })
+            .emit(&args.app);
             return Err(actor_error("listen_ws_connect_timeout"));
         }
         Ok(Err(e)) => {
             tracing::error!(error = ?e, "listen_ws_connect_failed(dual)");
+            let _ = (SessionEvent::ConnectionError {
+                session_id: args.session_id.clone(),
+                error: format!("listen_ws_connect_failed: {:?}", e),
+                retry_count: 0,
+            })
+            .emit(&args.app);
             return Err(actor_error(format!("listen_ws_connect_failed: {:?}", e)));
         }
         Ok(Ok(res)) => res,

plugins/listener/src/actors/source.rs

@@ -43,6 +43,7 @@ pub struct SourceArgs {
 }
 
 pub struct SourceState {
+    app: tauri::AppHandle,
     session_id: String,
     mic_device: Option<String>,
     onboarding: bool,
@@ -123,6 +124,14 @@ impl Actor for SourceActor {
         myself: ActorRef<Self::Msg>,
         args: Self::Arguments,
     ) -> Result<Self::State, ActorProcessingErr> {
+        if let Err(error) = (SessionEvent::InitializingAudio {
+            session_id: args.session_id.clone(),
+        })
+        .emit(&args.app)
+        {
+            tracing::error!(?error, "failed_to_emit_initializing_audio");
+        }
+
         let device_watcher = DeviceChangeWatcher::spawn(myself.clone());
 
         let silence_stream_tx = Some(hypr_audio::AudioOutput::silence());
@@ -134,6 +143,7 @@ impl Actor for SourceActor {
         let pipeline = Pipeline::new(args.app.clone(), args.session_id.clone());
 
         let mut st = SourceState {
+            app: args.app,
             session_id: args.session_id,
             mic_device,
             onboarding: args.onboarding,
@@ -221,11 +231,23 @@ async fn start_source_loop(
 
     st.pipeline.reset();
 
-    match new_mode {
+    let result = match new_mode {
         ChannelMode::MicOnly => start_source_loop_mic_only(myself, st).await,
         ChannelMode::SpeakerOnly => start_source_loop_speaker_only(myself, st).await,
         ChannelMode::MicAndSpeaker => start_source_loop_mic_and_speaker(myself, st).await,
+    };
+
+    if result.is_ok() {
+        if let Err(error) = (SessionEvent::AudioReady {
+            session_id: st.session_id.clone(),
+        })
+        .emit(&st.app)
+        {
+            tracing::error!(?error, "failed_to_emit_audio_ready");
+        }
     }
+
+    result
 }
 
 async fn start_source_loop_mic_only(

plugins/listener/src/events.rs

@@ -30,6 +30,20 @@ common_event_derives! {
             session_id: String,
             response: Box<StreamResponse>,
         },
+        #[serde(rename = "initializingAudio")]
+        InitializingAudio { session_id: String },
+        #[serde(rename = "audioReady")]
+        AudioReady { session_id: String },
+        #[serde(rename = "connecting")]
+        Connecting { session_id: String },
+        #[serde(rename = "connected")]
+        Connected { session_id: String },
+        #[serde(rename = "connectionError")]
+        ConnectionError {
+            session_id: String,
+            error: String,
+            retry_count: u32,
+        },
         ExitRequested
     }
 }