Move data streams into their own crate

.changeset/refactor_extract_data_stream_crates.md

@@ -0,0 +1,6 @@
+---
+livekit: patch
+livekit-ffi: patch
+---
+
+refactor: extract data-stream logic and shared types into new `livekit-common` and `livekit-data-stream` crates (public API unchanged; types are re-exported from `livekit`)

Cargo.toml

@@ -4,6 +4,8 @@ members = [
     "livekit",
     "livekit-api",
     "livekit-protocol",
+    "livekit-common",
+    "livekit-data-stream",
     "livekit-ffi",
     "livekit-uniffi",
     "livekit-datatrack",
@@ -50,6 +52,8 @@ livekit = { version = "0.7.51", path = "livekit" }
 livekit-api = { version = "0.5.5", path = "livekit-api" }
 livekit-ffi = { version = "0.12.69", path = "livekit-ffi" }
 livekit-datatrack = { version = "0.1.10", path = "livekit-datatrack" }
+livekit-common = { version = "0.1.0", path = "livekit-common" }
+livekit-data-stream = { version = "0.1.0", path = "livekit-data-stream" }
 livekit-protocol = { version = "0.7.10", path = "livekit-protocol" }
 # default-features off so each consumer selects its runtime explicitly
 # (livekit-runtime/tokio | /async | /dispatcher); otherwise the default `tokio`

livekit-api/Cargo.toml

@@ -101,6 +101,7 @@ __rustls-tls = ["tokio-tungstenite?/__rustls-tls", "reqwest?/__rustls"]
 
 [dependencies]
 livekit-protocol = { workspace = true }
+livekit-common = { workspace = true }
 thiserror = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 sha2 = "0.10"

livekit-api/src/signal_client/mod.rs

@@ -60,11 +60,7 @@
 const CLIENT_CAPABILITIES: &[proto::client_info::Capability] =
     &[proto::client_info::Capability::CapPacketTrailer];
 
-/// Default value for `ClientInfo.client_protocol` when a participant has not
-/// advertised one (treat as v1-only / no data-stream RPC support).
-pub const CLIENT_PROTOCOL_DEFAULT: i32 = 0;
-/// `ClientInfo.client_protocol` value indicating support for RPC v2 over data streams.
-pub const CLIENT_PROTOCOL_DATA_STREAM_RPC: i32 = 1;
+pub use livekit_common::{CLIENT_PROTOCOL_DATA_STREAM_RPC, CLIENT_PROTOCOL_DEFAULT};
 
 /// The client protocol which is sent to other clients and indicates the set of apis that other
 /// clients should assume this client supports.
@@ -1017,7 +1013,7 @@
     /// in `send`. The stream slot is None so any actual write would be dropped,
     /// which is fine — these tests only assert which side of the queue each
     /// message lands on.
     fn make_stub_inner() -> Arc<SignalInner> {
         Arc::new(SignalInner {
             stream: AsyncRwLock::new(None),
             token: Mutex::new(String::new()),

livekit-common/AGENTS.md

@@ -0,0 +1,30 @@
+# AGENTS.md
+
+## Architectural overview
+
+- Holds foundational, broadly-shared items used across multiple LiveKit crates (e.g. [`livekit`](../livekit/), [`livekit-api`](../livekit-api/), [`livekit-data-stream`](../livekit-data-stream/))
+- Internal crate — not for direct consumption by developers (public APIs live in the [`livekit`](../livekit/) crate)
+- Exists purely to avoid duplication and circular dependencies: an item needed by two or more downstream crates lives here instead of in any single one
+- Current contents set the bar for what fits: `ParticipantIdentity` (newtype), `EncryptionType` (enum + proto conversions), the `CLIENT_PROTOCOL_*` constants, and the `enum_dispatch!` macro
+
+## What belongs here
+
+- Small, self-contained, foundational items shared by **two or more** downstream crates:
+  - Newtypes and plain data enums (plus their `From`/`TryFrom` conversions)
+  - Simple constants
+  - Trivial, stateless helper functions and declarative macros
+- Every addition must be dependency-light (see Dependencies) and free of feature/business logic
+
+## What does NOT belong here
+
+- Feature or business logic — keep it in the feature's own crate (e.g. `livekit-data-stream`) or in `livekit`
+- Items used by only **one** crate — leave them in that crate until a second consumer actually needs them; do not hoist here speculatively
+- Stateful components — managers, actors, services, or anything holding runtime state
+- Wire/protocol types — those belong in `livekit-protocol` (this crate depends on it, never the reverse)
+- Anything that would require a heavy or environment-specific dependency (see Dependencies)
+
+## Dependencies
+
+- Keep the dependency list minimal — today it is only `livekit-protocol`
+- A dependency added here is forced onto **every** downstream crate; treat any new dependency as a red flag and justify it explicitly
+- Never pull in heavy or environment-specific deps (`libwebrtc`, an async runtime, networking, etc.) — a type that needs those belongs in a higher-level crate

livekit-common/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "livekit-common"
+description = "Common foundational types shared across LiveKit crates"
+version = "0.1.0"
+readme = "README.md"
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[dependencies]
+livekit-protocol = { workspace = true }

livekit-common/README.md

@@ -0,0 +1,6 @@
+# LiveKit Common
+
+An internal crate which holds shared data structures that many downstream modules all use, like
+`ParticipantIdentity` or `EncryptionType`.
+
+To build applications with LiveKit, please use the public APIs provided by the [livekit](../livekit) crate.

livekit-common/src/enum_dispatch.rs

@@ -0,0 +1,56 @@
+// Copyright 2026 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/// Generates methods on an enum that forward each call to the inner value of every variant.
+///
+/// Given a list of variants and a set of method signatures, this expands to a `match` over `self`
+/// that dispatches to the identically-named method on each variant's inner type, saving the
+/// boilerplate of writing one `match` arm per variant per method.
+///
+/// ```ignore
+/// impl AnyStreamInfo {
+///     enum_dispatch!(
+///         [Byte, Text];
+///         pub fn id(self: &Self) -> &str;
+///         pub fn total_length(self: &Self) -> Option<u64>;
+///     );
+/// }
+/// ```
+// TODO(theomonnom): Async methods
+#[macro_export]
+macro_rules! enum_dispatch {
+    // This arm is used to avoid nested loops with the arguments
+    // The arguments are transformed to $combined_args tt
+    (@match [$($variant:ident),+]: $fnc:ident, $self:ident, $combined_args:tt) => {
+        match $self {
+            $(
+                Self::$variant(inner) => inner.$fnc$combined_args,
+            )+
+        }
+    };
+
+    // Create the function and extract self fron the $args tt (little hack)
+    (@fnc [$($variant:ident),+]: $vis:vis fn $fnc:ident($self:ident: $sty:ty $(, $arg:ident: $t:ty)*) -> $ret:ty) => {
+        #[inline]
+        $vis fn $fnc($self: $sty, $($arg: $t),*) -> $ret {
+            $crate::enum_dispatch!(@match [$($variant),+]: $fnc, $self, ($($arg,)*))
+        }
+    };
+
+    ($variants:tt; $($vis:vis fn $fnc:ident$args:tt -> $ret:ty;)+) => {
+        $(
+            $crate::enum_dispatch!(@fnc $variants: $vis fn $fnc$args -> $ret);
+        )+
+    };
+}

livekit-common/src/lib.rs

@@ -0,0 +1,111 @@
+// Copyright 2026 LiveKit, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Foundational types shared across LiveKit crates: participant identities, the
+//! encryption enum, and client-protocol constants.
+
+use std::fmt::Display;
+
+use livekit_protocol as proto;
+
+mod enum_dispatch;
+
+// -------------------------------------------------------------------------------------------------
+// Client protocol
+// -------------------------------------------------------------------------------------------------
+
+/// Legacy client.
+pub const CLIENT_PROTOCOL_DEFAULT: i32 = 0;
+
+/// RPC v2 (see RPC spec).
+pub const CLIENT_PROTOCOL_DATA_STREAM_RPC: i32 = 1;
+
+// -------------------------------------------------------------------------------------------------
+// ParticipantIdentity
+// -------------------------------------------------------------------------------------------------
+
+#[derive(Clone, Default, Debug, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ParticipantIdentity(pub String);
+
+impl From<String> for ParticipantIdentity {
+    fn from(value: String) -> Self {
+        Self(value)
+    }
+}
+
+impl From<&str> for ParticipantIdentity {
+    fn from(value: &str) -> Self {
+        Self(value.to_string())
+    }
+}
+
+impl From<ParticipantIdentity> for String {
+    fn from(value: ParticipantIdentity) -> Self {
+        value.0
+    }
+}
+
+impl Display for ParticipantIdentity {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl ParticipantIdentity {
+    pub fn as_str(&self) -> &str {
+        &self.0
+    }
+}
+
+// -------------------------------------------------------------------------------------------------
+// EncryptionType
+// -------------------------------------------------------------------------------------------------
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EncryptionType {
+    #[default]
+    None,
+    Gcm,
+    Custom,
+}
+
+impl From<proto::encryption::Type> for EncryptionType {
+    fn from(value: proto::encryption::Type) -> Self {
+        match value {
+            proto::encryption::Type::None => Self::None,
+            proto::encryption::Type::Gcm => Self::Gcm,
+            proto::encryption::Type::Custom => Self::Custom,
+        }
+    }
+}
+
+impl From<EncryptionType> for proto::encryption::Type {
+    fn from(value: EncryptionType) -> Self {
+        match value {
+            EncryptionType::None => Self::None,
+            EncryptionType::Gcm => Self::Gcm,
+            EncryptionType::Custom => Self::Custom,
+        }
+    }
+}
+
+impl From<EncryptionType> for i32 {
+    fn from(value: EncryptionType) -> Self {
+        match value {
+            EncryptionType::None => 0,
+            EncryptionType::Gcm => 1,
+            EncryptionType::Custom => 2,
+        }
+    }
+}

livekit-data-stream/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "livekit-data-stream"
+description = "Data stream core logic for LiveKit"
+version = "0.1.0"
+readme = "README.md"
+license.workspace = true
+edition.workspace = true
+repository.workspace = true
+
+[features]
+# Exposes test-only hooks used by downstream crates' test suites (e.g.
+# `TextStreamReader::new_for_test`). Forwarded from the `livekit` crate's `__lk-e2e-test` feature.
+test-utils = []
+
+[dependencies]
+livekit-common = { workspace = true }
+livekit-protocol = { workspace = true }
+log = { workspace = true }
+thiserror = { workspace = true }
+parking_lot = { workspace = true }
+bytes = { workspace = true }
+tokio = { workspace = true, default-features = false, features = ["sync", "fs", "io-util", "rt"] }
+futures-util = { workspace = true, default-features = false, features = ["sink"] }
+prost = "0.12"
+chrono = "0.4.38"
+flate2 = "1"
+bmrng = "0.5.2"
+uuid = { version = "1", features = ["v4"] }
+
+[dev-dependencies]
+tokio = { workspace = true, default-features = false, features = ["macros", "rt", "rt-multi-thread", "time"] }