livekit-client 2.20.2 → 2.21.0

package/src/room/data-stream/outgoing/header-utils.ts

@@ -0,0 +1,87 @@
+import {
+  DataPacket,
+  DataStream_ByteHeader,
+  DataStream_CompressionType,
+  DataStream_Header,
+  DataStream_OperationType,
+  DataStream_TextHeader,
+} from '@livekit/protocol';
+import type { ByteStreamInfo, StreamTextOptions, TextStreamInfo } from '../../types';
+import { numberToBigInt } from '../../utils';
+
+/** The data-streams-v2 wire signals carried directly on the header: the compression flag and the
+ * inline single-packet payload. Both used to live in reserved header attributes; they are now
+ * first-class protobuf fields on `DataStream.Header`. */
+export interface StreamHeaderV2Fields {
+  /** Compression applied to the inline/chunked payload. Defaults to `NONE` when omitted. */
+  compression?: DataStream_CompressionType;
+  /** The full payload smuggled into the header for single-packet (inline) sends. */
+  inlineContent?: Uint8Array;
+}
+
+/** Builds the `DataStream_Header` for a text stream from its info and stream options. */
+export function buildTextStreamHeader(
+  info: TextStreamInfo,
+  options?: Pick<StreamTextOptions, 'version' | 'replyToStreamId' | 'type'>,
+  v2?: StreamHeaderV2Fields,
+): DataStream_Header {
+  return new DataStream_Header({
+    streamId: info.id,
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: numberToBigInt(info.timestamp),
+    totalLength: numberToBigInt(info.size),
+    attributes: info.attributes,
+    compression: v2?.compression ?? DataStream_CompressionType.NONE,
+    inlineContent: v2?.inlineContent,
+    contentHeader: {
+      case: 'textHeader',
+      value: new DataStream_TextHeader({
+        version: options?.version,
+        attachedStreamIds: info.attachedStreamIds,
+        replyToStreamId: options?.replyToStreamId,
+        operationType:
+          options?.type === 'update'
+            ? DataStream_OperationType.UPDATE
+            : DataStream_OperationType.CREATE,
+      }),
+    },
+  });
+}
+
+/** Builds the `DataStream_Header` for a byte stream from its info. */
+export function buildByteStreamHeader(
+  info: ByteStreamInfo,
+  v2?: StreamHeaderV2Fields,
+): DataStream_Header {
+  return new DataStream_Header({
+    streamId: info.id,
+    mimeType: info.mimeType,
+    topic: info.topic,
+    timestamp: numberToBigInt(info.timestamp),
+    totalLength: numberToBigInt(info.size),
+    attributes: info.attributes,
+    compression: v2?.compression ?? DataStream_CompressionType.NONE,
+    inlineContent: v2?.inlineContent,
+    contentHeader: {
+      case: 'byteHeader',
+      value: new DataStream_ByteHeader({
+        name: info.name,
+      }),
+    },
+  });
+}
+
+/** Wraps a `DataStream_Header` in a `DataPacket` ready to be sent over a data channel. */
+export function createStreamHeaderPacket(
+  header: DataStream_Header,
+  destinationIdentities?: Array<string>,
+): DataPacket {
+  return new DataPacket({
+    destinationIdentities,
+    value: {
+      case: 'streamHeader',
+      value: header,
+    },
+  });
+}

package/src/room/errors.ts

@@ -287,6 +287,12 @@ export enum DataStreamErrorReason {
 
   // Encryption type mismatch.
   EncryptionTypeMismatch = 8,
+
+  // The serialized stream header packet (driven mainly by attributes) exceeds the MTU budget.
+  HeaderTooLarge = 9,
+
+  // The stream's (decompressed) payload exceeds the maximum allowed size.
+  PayloadTooLarge = 10,
 }
 
 export class DataStreamError extends LivekitReasonedError<DataStreamErrorReason> {

package/src/room/participant/LocalParticipant.ts

@@ -82,8 +82,10 @@ import {
   sourceToKind,
 } from '../track/utils';
 import {
+  type ByteStreamInfo,
   type ChatMessage,
   type DataPublishOptions,
+  type SendBytesOptions,
   type SendFileOptions,
   type SendTextOptions,
   type StreamBytesOptions,
@@ -1851,6 +1853,17 @@ export default class LocalParticipant extends Participant {
     return this.roomOutgoingDataStreamManager.sendFile(file, options);
   }
 
+  /**
+   * Sends the given bytes to participants in the room via the data channel.
+   * For files, consider using {@link sendFile}; for longer/incremental payloads, {@link streamBytes}.
+   *
+   * @param bytes The byte payload
+   * @param options.topic Topic identifier used to route the stream to appropriate handlers.
+   */
+  async sendBytes(bytes: Uint8Array, options?: SendBytesOptions): Promise<ByteStreamInfo> {
+    return this.roomOutgoingDataStreamManager.sendBytes(bytes, options);
+  }
+
   /**
    * Stream bytes incrementally to participants in the room via the data channel.
    * For sending files, consider using {@link sendFile} instead.

package/src/room/participant/RemoteParticipant.ts

@@ -1,8 +1,9 @@
-import type {
-  ParticipantInfo,
-  SubscriptionError,
-  UpdateSubscription,
-  UpdateTrackSettings,
+import {
+  ClientInfo_Capability,
+  type ParticipantInfo,
+  type SubscriptionError,
+  type UpdateSubscription,
+  type UpdateTrackSettings,
 } from '@livekit/protocol';
 import type { SignalClient } from '../../api/SignalClient';
 import { DeferrableMap } from '../../utils/deferrable-map';
@@ -47,6 +48,16 @@ export default class RemoteParticipant extends Participant {
    **/
   clientProtocol: number;
 
+  /** The client capabilities the remote participant advertises (e.g. deflate-raw compression
+   * support). Used to decide which peer-to-peer features can be used when sending to them.
+   *
+   * Differs from clientProtocol in that these are truely optional "additions" which can be used
+   * or not depending on client specific attributes rather than protocol level invariants.
+   *
+   * @internal
+   **/
+  capabilities: Array<ClientInfo_Capability>;
+
   private volumeMap: Map<Track.Source, number>;
 
   private audioOutput?: AudioOutputOptions;
@@ -72,6 +83,7 @@ export default class RemoteParticipant extends Participant {
         return new RemoteDataTrack(info, manager, { publisherIdentity: pi.identity });
       }),
       pi.clientProtocol,
+      pi.capabilities,
     );
   }
 
@@ -95,6 +107,7 @@ export default class RemoteParticipant extends Participant {
     kind: ParticipantKind = ParticipantKind.STANDARD,
     remoteDataTracks: Array<RemoteDataTrack> = [],
     clientProtocol: number = CLIENT_PROTOCOL_DEFAULT,
+    capabilities: Array<ClientInfo_Capability> = [],
   ) {
     super(sid, identity || '', name, metadata, attributes, loggerOptions, kind);
     this.signalClient = signalClient;
@@ -108,6 +121,7 @@ export default class RemoteParticipant extends Participant {
     );
     this.volumeMap = new Map();
     this.clientProtocol = clientProtocol;
+    this.capabilities = capabilities;
   }
 
   protected addTrackPublication(publication: RemoteTrackPublication) {

package/src/room/rpc/client/RpcClientManager.test.ts

@@ -16,6 +16,8 @@ describe('RpcClientManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
 
       rpcClientManager = new RpcClientManager(
@@ -132,19 +134,13 @@ describe('RpcClientManager', () => {
 
   describe('v2 -> v2', () => {
     let rpcClientManager: RpcClientManager;
-    let mockStreamTextWriter: {
-      write: ReturnType<typeof vi.fn>;
-      close: ReturnType<typeof vi.fn>;
-    };
+    let sendTextMock: ReturnType<typeof vi.fn>;
     let mockOutgoingDataStreamManager: OutgoingDataStreamManager;
 
     beforeEach(() => {
-      mockStreamTextWriter = {
-        write: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-      };
+      sendTextMock = vi.fn().mockResolvedValue(undefined);
       mockOutgoingDataStreamManager = {
-        streamText: vi.fn().mockResolvedValue(mockStreamTextWriter),
+        sendText: sendTextMock,
       } as unknown as OutgoingDataStreamManager;
 
       rpcClientManager = new RpcClientManager(
@@ -171,7 +167,8 @@ describe('RpcClientManager', () => {
       });
 
       // Verify the data stream was used with correct attributes
-      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(mockOutgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        'request-payload',
         expect.objectContaining({
           topic: RPC_REQUEST_DATA_STREAM_TOPIC,
           destinationIdentities: ['destination-identity'],
@@ -182,8 +179,6 @@ describe('RpcClientManager', () => {
           }),
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith('request-payload');
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
 
       // No packet should have been emitted
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
@@ -213,7 +208,8 @@ describe('RpcClientManager', () => {
       });
 
       // Verify the data stream was used with correct attributes
-      expect(mockOutgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(mockOutgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        longPayload,
         expect.objectContaining({
           topic: RPC_REQUEST_DATA_STREAM_TOPIC,
           destinationIdentities: ['destination-identity'],
@@ -224,8 +220,6 @@ describe('RpcClientManager', () => {
           }),
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith(longPayload);
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
 
       // No packet should have been emitted
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
@@ -337,14 +331,14 @@ describe('RpcClientManager', () => {
     });
 
     it('should not drop ack and response that arrive before publish completes', async () => {
-      // Hold the publish path open by blocking writer.close() until we explicitly resolve it.
-      let resolveClose!: () => void;
-      const closeBlocked = new Promise<void>((resolve) => {
-        resolveClose = resolve;
+      // Hold the publish path open by blocking sendText() until we explicitly resolve it.
+      let resolveSend!: () => void;
+      const sendBlocked = new Promise<void>((resolve) => {
+        resolveSend = resolve;
       });
-      mockStreamTextWriter.close = vi.fn().mockReturnValue(closeBlocked);
+      sendTextMock.mockReturnValue(sendBlocked);
 
-      // Start performRpc but don't await its return yet. The synchronous prefix runs streamText.
+      // Start performRpc but don't await its return yet. The synchronous prefix runs sendText.
       const performRpcPromise = rpcClientManager.performRpc({
         destinationIdentity: 'destination-identity',
         method: 'test-method',
@@ -352,11 +346,10 @@ describe('RpcClientManager', () => {
         responseTimeout: 200,
       });
 
-      // streamText was called synchronously; pull the request id out of the attributes.
-      const streamTextCalls = (mockOutgoingDataStreamManager.streamText as ReturnType<typeof vi.fn>)
-        .mock.calls;
-      expect(streamTextCalls.length).toBe(1);
-      const requestId = streamTextCalls[0][0].attributes[RpcRequestAttrs.RPC_REQUEST_ID];
+      // sendText was called synchronously; pull the request id out of the attributes.
+      const sendTextCalls = sendTextMock.mock.calls;
+      expect(sendTextCalls.length).toBe(1);
+      const requestId = sendTextCalls[0][1].attributes[RpcRequestAttrs.RPC_REQUEST_ID];
 
       // Deliver ack and response BEFORE close() unblocks - the publish has not yet returned.
       rpcClientManager.handleIncomingRpcAck(requestId);
@@ -367,7 +360,7 @@ describe('RpcClientManager', () => {
       );
 
       // Now allow the publish path to complete.
-      resolveClose();
+      resolveSend();
 
       const [, completionPromise] = await performRpcPromise;
       await expect(completionPromise).resolves.toStrictEqual('response-payload');

package/src/room/rpc/client/RpcClientManager.ts

@@ -145,7 +145,7 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
   ) {
     if (remoteClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
       // Send payload as a data stream - a "version 2" rpc request.
-      const writer = await this.outgoingDataStreamManager.streamText({
+      await this.outgoingDataStreamManager.sendText(payload, {
         topic: RPC_REQUEST_DATA_STREAM_TOPIC,
         destinationIdentities: [destinationIdentity],
         attributes: {
@@ -155,9 +155,6 @@ export default class RpcClientManager extends (EventEmitter as new () => TypedEm
           [RpcRequestAttrs.RPC_REQUEST_VERSION]: `${RPC_VERSION_V2}`,
         },
       });
-
-      await writer.write(payload);
-      await writer.close();
       return;
     }
 

package/src/room/rpc/server/RpcServerManager.test.ts

@@ -2,7 +2,11 @@ import { RpcRequest } from '@livekit/protocol';
 import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
 import log from '../../../logger';
 import { subscribeToEvents } from '../../../utils/subscribeToEvents';
-import { CLIENT_PROTOCOL_DATA_STREAM_RPC, CLIENT_PROTOCOL_DEFAULT } from '../../../version';
+import {
+  CLIENT_PROTOCOL_DATA_STREAM_RPC,
+  CLIENT_PROTOCOL_DATA_STREAM_V2,
+  CLIENT_PROTOCOL_DEFAULT,
+} from '../../../version';
 import type RTCEngine from '../../RTCEngine';
 import OutgoingDataStreamManager from '../../data-stream/outgoing/OutgoingDataStreamManager';
 import { RPC_RESPONSE_DATA_STREAM_TOPIC, RpcError, RpcRequestAttrs } from '../utils';
@@ -17,6 +21,8 @@ describe('RpcServerManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
 
       rpcServerManager = new RpcServerManager(
@@ -184,22 +190,17 @@ describe('RpcServerManager', () => {
   describe('v2 -> v2', () => {
     let rpcServerManager: RpcServerManager;
     let outgoingDataStreamManager: OutgoingDataStreamManager;
-    let mockStreamTextWriter: {
-      write: ReturnType<typeof vi.fn>;
-      close: ReturnType<typeof vi.fn>;
-    };
 
     beforeEach(() => {
-      outgoingDataStreamManager = new OutgoingDataStreamManager({} as unknown as RTCEngine, log);
-
-      mockStreamTextWriter = {
-        write: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-      };
-      vi.spyOn(outgoingDataStreamManager, 'streamText').mockResolvedValue(
-        mockStreamTextWriter as any,
+      outgoingDataStreamManager = new OutgoingDataStreamManager(
+        {} as unknown as RTCEngine,
+        log,
+        (_identity) => CLIENT_PROTOCOL_DATA_STREAM_V2,
+        () => [],
       );
 
+      vi.spyOn(outgoingDataStreamManager, 'sendText').mockResolvedValue(undefined as any);
+
       rpcServerManager = new RpcServerManager(
         log,
         outgoingDataStreamManager,
@@ -243,15 +244,14 @@ describe('RpcServerManager', () => {
 
       // The response should have been sent via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        'response payload',
         expect.objectContaining({
           topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
           destinationIdentities: ['caller-identity'],
           attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith('response payload');
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
     });
 
     it('should receive a large rpc request (> 15kb) and send a large response via data stream from a participant', async () => {
@@ -277,15 +277,14 @@ describe('RpcServerManager', () => {
 
       // The response should have been sent via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalledWith(
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalledWith(
+        new Array(20_000).fill('B').join(''),
         expect.objectContaining({
           topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
           destinationIdentities: ['caller-identity'],
           attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
         }),
       );
-      expect(mockStreamTextWriter.write).toHaveBeenCalledWith(new Array(20_000).fill('B').join(''));
-      expect(mockStreamTextWriter.close).toHaveBeenCalled();
     });
 
     it('should register an RPC method handler', async () => {
@@ -317,7 +316,7 @@ describe('RpcServerManager', () => {
 
       // Response goes via data stream, not packet
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
-      expect(outgoingDataStreamManager.streamText).toHaveBeenCalled();
+      expect(outgoingDataStreamManager.sendText).toHaveBeenCalled();
     });
 
     it('should catch and transform unhandled errors in the RPC method handler', async () => {
@@ -414,7 +413,7 @@ describe('RpcServerManager', () => {
       const errorResponse = errorEvent.packet.value.value.value.value;
       expect(errorResponse.code).toStrictEqual(RpcError.ErrorCode.UNSUPPORTED_METHOD);
 
-      expect(outgoingDataStreamManager.streamText).not.toHaveBeenCalled();
+      expect(outgoingDataStreamManager.sendText).not.toHaveBeenCalled();
       expect(managerEvents.areThereBufferedEvents('sendDataPacket')).toBe(false);
     });
   });
@@ -424,8 +423,10 @@ describe('RpcServerManager', () => {
       const outgoingDataStreamManager = new OutgoingDataStreamManager(
         {} as unknown as RTCEngine,
         log,
+        (_identity) => CLIENT_PROTOCOL_DEFAULT,
+        () => [],
       );
-      const streamTextSpy = vi.spyOn(outgoingDataStreamManager, 'streamText');
+      const sendTextSpy = vi.spyOn(outgoingDataStreamManager, 'sendText');
 
       const rpcServerManager = new RpcServerManager(
         log,
@@ -457,7 +458,7 @@ describe('RpcServerManager', () => {
       assert(ackEvent.packet.value.case === 'rpcAck');
 
       // Response should be a v1 RpcResponse packet, not a data stream
-      expect(streamTextSpy).not.toHaveBeenCalled();
+      expect(sendTextSpy).not.toHaveBeenCalled();
       const responseEvent = await managerEvents.waitFor('sendDataPacket');
       assert(responseEvent.packet.value.case === 'rpcResponse');
       const rpcResponse = responseEvent.packet.value.value;

package/src/room/rpc/server/RpcServerManager.ts

@@ -263,13 +263,11 @@ export default class RpcServerManager extends (EventEmitter as new () => TypedEm
 
     if (callerClientProtocol >= CLIENT_PROTOCOL_DATA_STREAM_RPC) {
       // Send response as a data stream
-      const writer = await this.outgoingDataStreamManager.streamText({
+      await this.outgoingDataStreamManager.sendText(payload, {
         topic: RPC_RESPONSE_DATA_STREAM_TOPIC,
         destinationIdentities: [destinationIdentity],
         attributes: { [RpcRequestAttrs.RPC_REQUEST_ID]: requestId },
       });
-      await writer.write(payload);
-      await writer.close();
       return;
     }
 

package/src/room/types.ts

@@ -21,6 +21,21 @@ export interface SendTextOptions {
   attachments?: Array<File>;
   onProgress?: (progress: number) => void;
   attributes?: Record<string, string>;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+}
+
+export interface SendBytesOptions {
+  topic?: string;
+  destinationIdentities?: Array<string>;
+  attributes?: Record<string, string>;
+  onProgress?: (progress: number) => void;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
+  name?: string;
+  mimeType?: string;
 }
 
 export interface StreamTextOptions {
@@ -51,6 +66,9 @@ export type SendFileOptions = Pick<
 > & {
   onProgress?: (progress: number) => void;
   encryptionType?: Encryption_Type.NONE;
+  /** Whether to compress the payload (deflate-raw). Defaults to true. Compression is only applied
+   * when every recipient supports data streams v2 and the runtime can compress. */
+  compress?: boolean;
 };
 
 export type DataPublishOptions = {

package/src/room/utils.ts

@@ -781,6 +781,73 @@ export function splitUtf8(s: string, n: number): NonSharedUint8Array[] {
   return result;
 }
 
+/** Wraps a byte array in a `ReadableStream` that yields it as a single chunk and then closes. */
+export function readableFromBytes(bytes: NonSharedUint8Array): ReadableStream<NonSharedUint8Array> {
+  return new ReadableStream<NonSharedUint8Array>({
+    start(controller) {
+      controller.enqueue(bytes);
+      controller.close();
+    },
+  });
+}
+
+/**
+ * Re-chunks a byte stream into pieces of exactly `chunkSize` bytes (the final piece may be
+ * smaller), coalescing or splitting the source's pieces as needed. Memory use is bounded to roughly
+ * `chunkSize` plus one source read, so it never buffers the whole stream — used to pack
+ * `CompressionStream`/`file.stream()` output into MTU-sized data-stream chunks.
+ */
+export async function* readBytesInChunks(
+  source: ReadableStream<NonSharedUint8Array>,
+  chunkSize: number,
+): AsyncGenerator<NonSharedUint8Array> {
+  const reader = source.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value.byteLength === 0) {
+        continue;
+      }
+      const merged = new Uint8Array(buffer.byteLength + value.byteLength);
+      merged.set(buffer);
+      merged.set(value, buffer.byteLength);
+      buffer = merged;
+      while (buffer.byteLength >= chunkSize) {
+        yield buffer.slice(0, chunkSize);
+        buffer = buffer.slice(chunkSize);
+      }
+    }
+    if (buffer.byteLength > 0) {
+      yield buffer;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+/** Encodes a byte array as a base64 string (suitable for embedding binary data in a string field). */
+export function encodeBase64(bytes: Uint8Array): string {
+  let binary = '';
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+/** Decodes a base64 string (as produced by {@link encodeBase64}) back into a byte array. */
+export function decodeBase64(base64: string): Uint8Array {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
 export function extractMaxAgeFromRequestHeaders(headers: Headers): number | undefined {
   const cacheControl = headers.get('Cache-Control');
   if (cacheControl) {

package/src/version.ts

@@ -8,7 +8,11 @@ export const CLIENT_PROTOCOL_DEFAULT = 0;
 /** Replaces RPC v1 protocol with a v2 data streams based one to support unlimited request /
  * response payload length. */
 export const CLIENT_PROTOCOL_DATA_STREAM_RPC = 1;
+/** "Data streams v2": the client knows how to receive a single-packet data stream (a stream whose
+ * entire payload is smuggled into the header packet, with no chunk/trailer packets). Senders only
+ * use the single-packet optimization when the recipient advertises at least this protocol. */
+export const CLIENT_PROTOCOL_DATA_STREAM_V2 = 2;
 
 /** The client protocol version indicates what level of support that the client has for
  * client <-> client api interactions. */
-export const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_RPC;
+export const clientProtocol = CLIENT_PROTOCOL_DATA_STREAM_V2;