feat(ws): include active subscriptions in ConnectionLost for reconnection

BREAKING CHANGE: StreamMessage::ConnectionLost now has two fields:
`reason` and `subscriptions`. Update pattern matches accordingly.

- Add `subscriptions: Vec<(Channel, Vec<String>)>` to ConnectionLost
  containing channels and markets active at disconnect time
- Move SubscriptionState and SharedSubscriptions to session module
- Simplify session constructors into single connect() method
- Improve reconnection documentation with resubscription examples
- Add CHANGELOG.md
- Bump version to 0.2.0

Author: pbeets

CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-01-18
+
+### Added
+
+- `ConnectionLost` now includes a `subscriptions` field containing the channels and
+  markets that were active at the time of disconnection. This enables automatic
+  resubscription after reconnecting.
+
+### Changed
+
+- **Breaking:** `StreamMessage::ConnectionLost` variant now has two fields: `reason`
+  and `subscriptions`. Update pattern matches from `ConnectionLost { reason }` to
+  `ConnectionLost { reason, .. }` or `ConnectionLost { reason, subscriptions }`.
+- Internal: `SubscriptionState` and `SharedSubscriptions` types moved from `client`
+  module to `session` module and made public for internal sharing.
+- Internal: Simplified `KalshiStreamSession` constructors by consolidating
+  `connect()`, `connect_with_health()`, and `connect_with_ready()` into a single
+  `connect()` method. This is not a breaking change as `KalshiStreamSession` is
+  not part of the public API.
+
+### Fixed
+
+- Improved documentation for WebSocket reconnection patterns with examples showing
+  how to use the new `subscriptions` field.
+
+## [0.1.0] - 2026-01-15
+
+### Added
+
+- Initial release
+- REST API client with full endpoint coverage
+- WebSocket streaming client with subscription management
+- RSA-PSS authentication
+- Typed `DisconnectReason` enum for connection lifecycle events
+- Health monitoring with configurable ping/pong timeouts
+- Connection strategies: `Simple` (fast-fail) and `Retry` (exponential backoff)
+- Support for all public and authenticated WebSocket channels

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "kalshi-trade-rs"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 authors = ["pbeets"]
 description = "Rust client for the Kalshi trading API and WebSocket streams"

Cargo.toml

@@ -80,7 +80,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 StreamMessage::Trade(t) => {
                     println!("[TRADE] {} {} @ {}¢", t.market_ticker, t.count, t.yes_price);
                 }
-                StreamMessage::ConnectionLost { reason } => {
+                StreamMessage::ConnectionLost { reason, .. } => {
                     println!("Connection lost: {}", reason);
                     break;
                 }

README.md

@@ -107,7 +107,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     println!("[CLOSED] {}", reason);
                     break;
                 }
-                StreamMessage::ConnectionLost { reason } => {
+                StreamMessage::ConnectionLost { reason, .. } => {
                     println!("[CONNECTION LOST] {}", reason);
                     break;
                 }

examples/stream_lifecycle.rs

@@ -58,8 +58,12 @@ async fn run_stream(config: &KalshiConfig) -> Result<String, Box<dyn std::error:
     loop {
         match handle.update_receiver.recv().await {
             Ok(update) => match &update.msg {
-                StreamMessage::Closed { reason } => return Ok(reason.clone()),
-                StreamMessage::ConnectionLost { reason } => {
+                StreamMessage::Closed { reason } => return Ok(reason.to_string()),
+                StreamMessage::ConnectionLost { reason, subscriptions } => {
+                    eprintln!("Connection lost: {reason}");
+                    if !subscriptions.is_empty() {
+                        eprintln!("Lost subscriptions: {subscriptions:?}");
+                    }
                     return Err(format!("Connection lost: {reason}").into());
                 }
                 StreamMessage::Fill(f) => {

examples/stream_reconnect.rs

@@ -117,7 +117,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     println!("[CLOSED] {}", reason);
                     break;
                 }
-                StreamMessage::ConnectionLost { reason } => {
+                StreamMessage::ConnectionLost { reason, .. } => {
                     println!("[CONNECTION LOST] {}", reason);
                     break;
                 }

examples/stream_ticker.rs

@@ -83,7 +83,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
                     println!("[CLOSED] {}", reason);
                     break;
                 }
-                StreamMessage::ConnectionLost { reason } => {
+                StreamMessage::ConnectionLost { reason, .. } => {
                     println!("[CONNECTION LOST] {}", reason);
                     break;
                 }

examples/stream_user_channels.rs

@@ -29,7 +29,7 @@
 //!         StreamMessage::Ticker(data) => {
 //!             println!("{}: {}¢", data.market_ticker, data.price);
 //!         }
-//!         StreamMessage::ConnectionLost { reason } => {
+//!         StreamMessage::ConnectionLost { reason, .. } => {
 //!             eprintln!("Connection lost: {}", reason);
 //!             break; // Handle reconnection (see below)
 //!         }
@@ -99,7 +99,7 @@
 //!                 StreamMessage::Ticker(data) => {
 //!                     println!("{}: {}¢", data.market_ticker, data.price);
 //!                 }
-//!                 StreamMessage::ConnectionLost { reason } => {
+//!                 StreamMessage::ConnectionLost { reason, .. } => {
 //!                     eprintln!("Connection lost: {}", reason);
 //!                     break; // Exit inner loop to reconnect
 //!                 }

src/ws.rs

@@ -139,6 +139,9 @@ println!("Ticker markets: {:?}", handle.markets(Channel::Ticker));
 
 ### Reconnection Pattern
 
+When a connection is lost unexpectedly, `ConnectionLost` includes the subscriptions
+that were active at the time of disconnection. Use this to resubscribe after reconnecting:
+
 ```rust
 use kalshi_trade_rs::ws::{ConnectStrategy, KalshiStreamClient, StreamMessage};
 
@@ -152,8 +155,23 @@ let mut handle = client.handle();
 loop {
     match handle.update_receiver.recv().await {
         Ok(update) => match &update.msg {
-            StreamMessage::ConnectionLost { reason } => {
-                // Reconnect logic here
+            StreamMessage::ConnectionLost { reason, subscriptions } => {
+                eprintln!("Connection lost: {reason}");
+                // subscriptions: Vec<(Channel, Vec<String>)>
+                // Contains channels and their markets that were subscribed
+                // before disconnect. Use this to resubscribe after reconnecting:
+                //
+                // let new_client = KalshiStreamClient::connect(&config).await?;
+                // let mut new_handle = new_client.handle();
+                // for (channel, markets) in subscriptions {
+                //     let market_refs: Vec<&str> = markets.iter().map(|s| s.as_str()).collect();
+                //     new_handle.subscribe(channel, &market_refs).await?;
+                // }
+                break;
+            }
+            StreamMessage::Closed { reason } => {
+                // Clean close (client-initiated or server close frame)
+                println!("Connection closed: {reason}");
                 break;
             }
             _ => { /* process update */ }