fix(listen): prevent panic on websocket keep-alive after close_stream

[lukeocodes]

Summary

• Replace .expect() with let _ = when sending KeepAlive in the worker loop, preventing a panic when close_stream() closes the channel before the keep-alive timer fires
• Add regression tests (keepalive_then_close_stream_panic_repro and loop variant) that reproduce the race condition
• Add standalone example 16_keepalive_close_stream demonstrating correct keep-alive + close_stream behavior end-to-end
• Add .env to .gitignore

Closes #143

Test plan

• cargo check --example 16_keepalive_close_stream compiles cleanly
• cargo run --example 16_keepalive_close_stream completes without panic
• DEEPGRAM_API_KEY=... cargo test keepalive_then_close_stream_panic_repro --features listen -- --ignored --nocapture passes
• DEEPGRAM_API_KEY=... cargo test keepalive_close_stream_panic_repro_loop --features listen -- --ignored --nocapture passes

[Copilot]

Copilot encountered an error and was unable to review this pull request. You can try again by re-requesting a review.

[Copilot]

Pull request overview

Copilot reviewed 3 out of 4 changed files in this pull request and generated 3 comments.

Comments suppressed due to low confidence (1)

src/listen/websocket.rs:492

• pending::<()>().await in the sleep branch will permanently block the worker once the timer fires when keep_alive is false or is_open is false, preventing further processing of websocket responses (including final transcripts / close frames). Consider disabling the sleep future before the select_biased! (e.g., by selecting on pending() instead of sleep when keep-alive is disabled) or simply no-op in this branch rather than awaiting a never-resolving future.

                    let _ = message_tx.send(WsMessage::ControlMessage(ControlMessage::KeepAlive)).await;
                    last_sent_message = tokio::time::Instant::now();
                } else {
                    pending::<()>().await;
                }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 3 out of 4 changed files in this pull request and generated 2 comments.

Comments suppressed due to low confidence (1)

src/listen/websocket.rs:492

• In the sleep branch, the else { pending::<()>().await; } will block the worker forever once the 3s timer fires while keep_alive is false or is_open is false. That prevents processing further websocket responses (including the close/terminal response) and can stall shutdown. Consider disabling the timer by making the future in the select be pending() when keep-alive is disabled (or continue when the sleep fires) rather than awaiting pending() inside the branch body.

                    last_sent_message = tokio::time::Instant::now();
                } else {
                    pending::<()>().await;
                }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

Pull request overview

Copilot reviewed 3 out of 4 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (1)

src/listen/websocket.rs:493

• The sleep branch awaits pending::<()>() when keep_alive is false or is_open is false. Because this runs after the sleep has already fired and the select branch is chosen, it will park the worker forever and stop processing both websocket responses and inbound control/audio messages (e.g., after CloseStream). Consider moving the condition into the select_biased! branch guard (or constructing sleep as a pending() future when disabled) so the worker loop can continue to handle responses/shutdown cleanly without deadlocking.

            _ = sleep.fuse() => {
                // eprintln!("<worker> sleep");
                if keep_alive && is_open {
                    // Ignore send errors: the channel may have been closed by
                    // close_stream() (via close_channel()) before the worker
                    // processes the pending CloseStream message. In that case
                    // the next iteration will handle CloseStream, stop sending new
                    // messages, and proceed toward shutdown.
                    let _ = message_tx.send(WsMessage::ControlMessage(ControlMessage::KeepAlive)).await;
                    last_sent_message = tokio::time::Instant::now();
                } else {
                    pending::<()>().await;
                }

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

In the looped regression test, close_stream() errors are ignored (let _ = ...). That can produce false positives if closing fails and the keep-alive send path is never reached. Consider asserting the close succeeds (or checking state) to keep the test meaningful.

Suggested change

	let _ = handle.close_stream().await;
	handle.close_stream().await.expect("close_stream");