BasedHardware
diff --git a/‎desktop/Backend-Rust/src/routes/proxy.rs‎
Lines changed: 86 additions & 29 deletions b/‎desktop/Backend-Rust/src/routes/proxy.rs‎
Lines changed: 86 additions & 29 deletions
diff --git a/‎desktop/CHANGELOG.json‎
Lines changed: 4 additions & 2 deletions b/‎desktop/CHANGELOG.json‎
Lines changed: 4 additions & 2 deletions
@@ -253,7 +253,17 @@ async fn deepgram_ws_proxy(
     }))
 }
 
+/// Which side of the proxy terminated first
+#[derive(Debug)]
+enum ProxyCloseOrigin {
+    ClientClosed,
+    UpstreamClosed,
+    ClientError,
+    UpstreamError,
+}
+
 /// Bidirectional WebSocket proxy between client (axum) and upstream (tokio-tungstenite).
+/// When one side closes or errors, a close frame is forwarded to the other side before teardown.
 async fn proxy_ws_bidirectional(
     client_socket: axum::extract::ws::WebSocket,
     upstream_url: &str,
@@ -278,47 +288,71 @@ async fn proxy_ws_bidirectional(
 
     // Client → Upstream
     let client_to_upstream = async {
-        while let Some(Ok(msg)) = client_stream.next().await {
-            let tung_msg = match msg {
-                AxumMsg::Text(t) => TungMsg::Text(t),
-                AxumMsg::Binary(b) => TungMsg::Binary(b),
-                AxumMsg::Ping(p) => TungMsg::Ping(p),
-                AxumMsg::Pong(p) => TungMsg::Pong(p),
-                AxumMsg::Close(_) => {
-                    let _ = upstream_sink.close().await;
-                    return;
+        while let Some(result) = client_stream.next().await {
+            match result {
+                Ok(msg) => {
+                    let tung_msg = match msg {
+                        AxumMsg::Text(t) => TungMsg::Text(t),
+                        AxumMsg::Binary(b) => TungMsg::Binary(b),
+                        AxumMsg::Ping(p) => TungMsg::Ping(p),
+                        AxumMsg::Pong(p) => TungMsg::Pong(p),
+                        AxumMsg::Close(_) => {
+                            let _ = upstream_sink.close().await;
+                            return ProxyCloseOrigin::ClientClosed;
+                        }
+                    };
+                    if upstream_sink.send(tung_msg).await.is_err() {
+                        return ProxyCloseOrigin::UpstreamError;
+                    }
                 }
-            };
-            if upstream_sink.send(tung_msg).await.is_err() {
-                return;
+                Err(_) => return ProxyCloseOrigin::ClientError,
             }
         }
+        ProxyCloseOrigin::ClientClosed
     };
 
     // Upstream → Client
     let upstream_to_client = async {
-        while let Some(Ok(msg)) = upstream_stream.next().await {
-            let axum_msg = match msg {
-                TungMsg::Text(t) => AxumMsg::Text(t),
-                TungMsg::Binary(b) => AxumMsg::Binary(b),
-                TungMsg::Ping(p) => AxumMsg::Ping(p),
-                TungMsg::Pong(p) => AxumMsg::Pong(p),
-                TungMsg::Close(_) => {
-                    let _ = client_sink.close().await;
-                    return;
+        while let Some(result) = upstream_stream.next().await {
+            match result {
+                Ok(msg) => {
+                    let axum_msg = match msg {
+                        TungMsg::Text(t) => AxumMsg::Text(t),
+                        TungMsg::Binary(b) => AxumMsg::Binary(b),
+                        TungMsg::Ping(p) => AxumMsg::Ping(p),
+                        TungMsg::Pong(p) => AxumMsg::Pong(p),
+                        TungMsg::Close(_) => {
+                            let _ = client_sink.close().await;
+                            return ProxyCloseOrigin::UpstreamClosed;
+                        }
+                        TungMsg::Frame(_) => continue,
+                    };
+                    if client_sink.send(axum_msg).await.is_err() {
+                        return ProxyCloseOrigin::ClientError;
+                    }
                 }
-                TungMsg::Frame(_) => continue,
-            };
-            if client_sink.send(axum_msg).await.is_err() {
-                return;
+                Err(_) => return ProxyCloseOrigin::UpstreamError,
             }
         }
+        ProxyCloseOrigin::UpstreamClosed
     };
 
-    // Run both directions concurrently; when either ends, drop both
-    tokio::select! {
-        _ = client_to_upstream => {},
-        _ = upstream_to_client => {},
+    // Run both directions concurrently; when either ends, gracefully close the other side
+    let origin = tokio::select! {
+        origin = client_to_upstream => origin,
+        origin = upstream_to_client => origin,
+    };
+
+    // Forward close frame to the surviving side with a timeout to prevent hanging
+    let close_timeout = std::time::Duration::from_secs(5);
+    tracing::debug!("deepgram_ws_proxy: proxy ended ({:?})", origin);
+    match origin {
+        ProxyCloseOrigin::UpstreamClosed | ProxyCloseOrigin::UpstreamError => {
+            let _ = tokio::time::timeout(close_timeout, client_sink.close()).await;
+        }
+        ProxyCloseOrigin::ClientClosed | ProxyCloseOrigin::ClientError => {
+            let _ = tokio::time::timeout(close_timeout, upstream_sink.close()).await;
+        }
     }
 
     Ok(())
@@ -555,4 +589,27 @@ mod tests {
         let msg = parsed["error"]["message"].as_str().unwrap().to_lowercase();
         assert!(msg.contains("resource exhausted"));
     }
+
+    // --- ProxyCloseOrigin ---
+
+    #[test]
+    fn proxy_close_origin_debug_variants() {
+        // Verify all variants exist and produce distinct debug output
+        let variants = [
+            ProxyCloseOrigin::ClientClosed,
+            ProxyCloseOrigin::UpstreamClosed,
+            ProxyCloseOrigin::ClientError,
+            ProxyCloseOrigin::UpstreamError,
+        ];
+        let debug_strs: Vec<String> = variants.iter().map(|v| format!("{:?}", v)).collect();
+        assert_eq!(debug_strs.len(), 4);
+        // All distinct
+        let unique: std::collections::HashSet<&String> = debug_strs.iter().collect();
+        assert_eq!(unique.len(), 4, "All ProxyCloseOrigin variants should have distinct Debug output");
+        // Verify expected names
+        assert!(debug_strs.contains(&"ClientClosed".to_string()));
+        assert!(debug_strs.contains(&"UpstreamClosed".to_string()));
+        assert!(debug_strs.contains(&"ClientError".to_string()));
+        assert!(debug_strs.contains(&"UpstreamError".to_string()));
+    }
 }
@@ -1,5 +1,7 @@
 {
-  "unreleased": [],
+  "unreleased": [
+    "Fixed WebSocket transcription disconnects: proper handshake detection, unlimited retry with backoff, and thread-safe connection state"
+  ],
   "releases": [
     {
       "version": "0.11.218",
@@ -103,7 +105,7 @@
       "version": "0.11.202",
       "date": "2026-03-31",
       "changes": [
-        "Fixed WebSocket transcription disconnects: proper handshake detection, audio buffering during reconnection, unlimited retry with backoff, and thread-safe connection state",
+        "Fixed WebSocket transcription disconnects: proper handshake detection, unlimited retry with backoff, and thread-safe connection state",
         "Fixed UI freezes caused by dock tile updates when receiving support messages"
       ]
     },
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,7 @@`
`1`	`1`	`{`
`2`		`- "unreleased": [],`
	`2`	`+ "unreleased": [`
	`3`	`+ "Fixed WebSocket transcription disconnects: proper handshake detection, unlimited retry with backoff, and thread-safe connection state"`
	`4`	`+ ],`
`3`	`5`	`"releases": [`
`4`	`6`	`{`
`5`	`7`	`"version": "0.11.218",`
`@@ -103,7 +105,7 @@`
`103`	`105`	`"version": "0.11.202",`
`104`	`106`	`"date": "2026-03-31",`
`105`	`107`	`"changes": [`
`106`		`- "Fixed WebSocket transcription disconnects: proper handshake detection, audio buffering during reconnection, unlimited retry with backoff, and thread-safe connection state",`
	`108`	`+ "Fixed WebSocket transcription disconnects: proper handshake detection, unlimited retry with backoff, and thread-safe connection state",`
`107`	`109`	`"Fixed UI freezes caused by dock tile updates when receiving support messages"`
`108`	`110`	`]`
`109`	`111`	`},`