livekit-client 2.8.1 → 2.9.1

package/dist/ts4.2/src/room/participant/LocalParticipant.d.ts

@@ -1,12 +1,13 @@
 import { Codec, ParticipantInfo, ParticipantPermission } from '@livekit/protocol';
 import type { InternalRoomOptions } from '../../options';
 import type RTCEngine from '../RTCEngine';
+import { TextStreamWriter } from '../StreamWriter';
 import type { PerformRpcParams, RpcInvocationData } from '../rpc';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import { Track } from '../track/Track';
 import type { AudioCaptureOptions, BackupVideoCodec, CreateLocalTracksOptions, ScreenShareCaptureOptions, TrackPublishOptions, VideoCaptureOptions } from '../track/options';
-import type { ChatMessage, DataPublishOptions } from '../types';
+import type { ChatMessage, DataPublishOptions, SendTextOptions, StreamTextOptions, TextStreamInfo } from '../types';
 import Participant from './Participant';
 import type { ParticipantTrackPermission } from './ParticipantTrackPermission';
 export default class LocalParticipant extends Participant {
@@ -28,13 +29,13 @@ export default class LocalParticipant extends Participant {
     private roomOptions;
     private encryptionType;
     private reconnectFuture?;
+    private rpcHandlers;
     private pendingSignalRequests;
     private enabledPublishVideoCodecs;
-    private rpcHandlers;
     private pendingAcks;
     private pendingResponses;
     /** @internal */
-    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions);
+    constructor(sid: string, identity: string, engine: RTCEngine, options: InternalRoomOptions, roomRpcHandlers: Map<string, (data: RpcInvocationData) => Promise<string>>);
     get lastCameraError(): Error | undefined;
     get lastMicrophoneError(): Error | undefined;
     get isE2EEEnabled(): boolean;
@@ -148,13 +149,29 @@ export default class LocalParticipant extends Participant {
      * @param digit DTMF digit
      */
     publishDtmf(code: number, digit: string): Promise<void>;
-    sendChatMessage(text: string): Promise<ChatMessage>;
+    sendChatMessage(text: string, options?: SendTextOptions): Promise<ChatMessage>;
     editChatMessage(editText: string, originalMessage: ChatMessage): Promise<{
         readonly message: string;
         readonly editTimestamp: number;
         readonly id: string;
         readonly timestamp: number;
+        readonly attachedFiles?: Array<File>;
+    }>;
+    sendText(text: string, options?: SendTextOptions): Promise<TextStreamInfo>;
+    /**
+     * @internal
+     * @experimental CAUTION, might get removed in a minor release
+     */
+    streamText(options?: StreamTextOptions): Promise<TextStreamWriter>;
+    sendFile(file: File, options?: {
+        mimeType?: string;
+        topic?: string;
+        destinationIdentities?: Array<string>;
+        onProgress?: (progress: number) => void;
+    }): Promise<{
+        id: string;
     }>;
+    private _sendFile;
     /**
      * Initiate an RPC call to a remote participant
      * @param params - Parameters for initiating the RPC call, see {@link PerformRpcParams}
@@ -163,36 +180,11 @@ export default class LocalParticipant extends Participant {
      */
     performRpc({ destinationIdentity, method, payload, responseTimeout, }: PerformRpcParams): Promise<string>;
     /**
-     * Establishes the participant as a receiver for calls of the specified RPC method.
-     * Will overwrite any existing callback for the same method.
-     *
-     * @param method - The name of the indicated RPC method
-     * @param handler - Will be invoked when an RPC request for this method is received
-     * @returns A promise that resolves when the method is successfully registered
-     *
-     * @example
-     * ```typescript
-     * room.localParticipant?.registerRpcMethod(
-     *   'greet',
-     *   async (data: RpcInvocationData) => {
-     *     console.log(`Received greeting from ${data.callerIdentity}: ${data.payload}`);
-     *     return `Hello, ${data.callerIdentity}!`;
-     *   }
-     * );
-     * ```
-     *
-     * The handler should return a Promise that resolves to a string.
-     * If unable to respond within `responseTimeout`, the request will result in an error on the caller's side.
-     *
-     * You may throw errors of type `RpcError` with a string `message` in the handler,
-     * and they will be received on the caller's side with the message intact.
-     * Other errors thrown in your handler will not be transmitted as-is, and will instead arrive to the caller as `1500` ("Application Error").
+     * @deprecated use `room.registerRpcMethod` instead
      */
     registerRpcMethod(method: string, handler: (data: RpcInvocationData) => Promise<string>): void;
     /**
-     * Unregisters a previously registered RPC method.
-     *
-     * @param method - The name of the RPC method to unregister
+     * @deprecated use `room.unregisterRpcMethod` instead
      */
     unregisterRpcMethod(method: string): void;
     /**
@@ -215,14 +207,9 @@ export default class LocalParticipant extends Participant {
     setTrackSubscriptionPermissions(allParticipantsAllowed: boolean, participantTrackPermissions?: ParticipantTrackPermission[]): void;
     private handleIncomingRpcAck;
     private handleIncomingRpcResponse;
-    private handleIncomingRpcRequest;
     /** @internal */
     private publishRpcRequest;
     /** @internal */
-    private publishRpcResponse;
-    /** @internal */
-    private publishRpcAck;
-    /** @internal */
     handleParticipantDisconnected(participantIdentity: string): void;
     /** @internal */
     setEnabledPublishCodecs(codecs: Codec[]): void;

package/dist/ts4.2/src/room/track/LocalTrack.d.ts

@@ -38,6 +38,7 @@ export default abstract class LocalTrack<TrackKind extends Track.Kind = Track.Ki
     get isUpstreamPaused(): boolean;
     get isUserProvided(): boolean;
     get mediaStreamTrack(): MediaStreamTrack;
+    get isLocal(): boolean;
     /**
      * @internal
      * returns mediaStreamTrack settings of the capturing mediastreamtrack source - ignoring processors

package/dist/ts4.2/src/room/track/LocalTrackPublication.d.ts

@@ -15,6 +15,7 @@ export default class LocalTrackPublication extends TrackPublication {
     get isMuted(): boolean;
     get audioTrack(): LocalAudioTrack | undefined;
     get videoTrack(): LocalVideoTrack | undefined;
+    get isLocal(): boolean;
     /**
      * Mute the track associated with this publication
      */

package/dist/ts4.2/src/room/track/RemoteTrack.d.ts

@@ -4,6 +4,7 @@ export default abstract class RemoteTrack<TrackKind extends Track.Kind = Track.K
     /** @internal */
     receiver: RTCRtpReceiver | undefined;
     constructor(mediaTrack: MediaStreamTrack, sid: string, kind: TrackKind, receiver: RTCRtpReceiver, loggerOptions?: LoggerOptions);
+    get isLocal(): boolean;
     /** @internal */
     setMuted(muted: boolean): void;
     /** @internal */

package/dist/ts4.2/src/room/track/RemoteTrackPublication.d.ts

@@ -27,6 +27,7 @@ export default class RemoteTrackPublication extends TrackPublication {
     get isSubscribed(): boolean;
     get isDesired(): boolean;
     get isEnabled(): boolean;
+    get isLocal(): boolean;
     /**
      * disable server from sending down data for this track. this is useful when
      * the participant is off screen, you may disable streaming down their video

package/dist/ts4.2/src/room/track/Track.d.ts

@@ -46,6 +46,7 @@ export declare abstract class Track<TrackKind extends Track.Kind = Track.Kind> e
     /** current receive bits per second */
     get currentBitrate(): number;
     get mediaStreamTrack(): MediaStreamTrack;
+    abstract get isLocal(): boolean;
     /**
      * @internal
      * used for keep mediaStream's first id, since it's id might change

package/dist/ts4.2/src/room/track/TrackPublication.d.ts

@@ -9,7 +9,7 @@ import type RemoteTrack from './RemoteTrack';
 import RemoteVideoTrack from './RemoteVideoTrack';
 import { Track } from './Track';
 declare const TrackPublication_base: new () => TypedEventEmitter<PublicationEventCallbacks>;
-export declare class TrackPublication extends TrackPublication_base {
+export declare abstract class TrackPublication extends TrackPublication_base {
     kind: Track.Kind;
     trackName: string;
     trackSid: Track.SID;
@@ -37,6 +37,7 @@ export declare class TrackPublication extends TrackPublication_base {
     get isEnabled(): boolean;
     get isSubscribed(): boolean;
     get isEncrypted(): boolean;
+    abstract get isLocal(): boolean;
     /**
      * an [AudioTrack] if this publication holds an audio track
      */

package/dist/ts4.2/src/room/track/options.d.ts

@@ -6,8 +6,7 @@ export interface TrackPublishDefaults {
      */
     videoEncoding?: VideoEncoding;
     /**
-     * Multi-codec Simulcast
-     * VP9 and AV1 are not supported by all browser clients. When backupCodec is
+     * Advanced codecs (VP9/AV1/H265) are not supported by all browser clients. When backupCodec is
      * set, when an incompatible client attempts to subscribe to the track, LiveKit
      * will automatically publish a secondary track encoded with the backup codec.
      *
@@ -20,6 +19,19 @@ export interface TrackPublishDefaults {
         codec: BackupVideoCodec;
         encoding?: VideoEncoding;
     };
+    /**
+     * When backup codec is enabled, there are two options to decide whether to
+     * send the primary codec at the same time:
+     *   * codec regression: publisher stops sending primary codec and all subscribers
+     *       will receive backup codec even if the primary codec is supported on their browser. It is the default
+     *       behavior and provides maximum compatibility. It also reduces CPU
+     *       and bandwidth consumption for publisher.
+     *   * multi-codec simulcast: publisher encodes and sends both codecs at same time,
+     *       subscribers will get most efficient codec. It will provide most bandwidth
+     *       efficiency, especially in the large 1:N room but requires more device performance
+     *       and bandwidth consumption for publisher.
+     */
+    backupCodecPolicy?: BackupCodecPolicy;
     /**
      * encoding parameters for screen share track
      */
@@ -280,6 +292,10 @@ export declare const videoCodecs: readonly [
 export type VideoCodec = (typeof videoCodecs)[number];
 export type BackupVideoCodec = (typeof backupCodecs)[number];
 export declare function isBackupCodec(codec: string): codec is BackupVideoCodec;
+export declare enum BackupCodecPolicy {
+    REGRESSION = 0,
+    SIMULCAST = 1
+}
 /**
  * scalability modes for svc.
  */

package/dist/ts4.2/src/room/types.d.ts

@@ -1,3 +1,4 @@
+import type { DataStream_Chunk } from '@livekit/protocol';
 export type SimulationOptions = {
     publish?: {
         audio?: boolean;
@@ -11,6 +12,22 @@ export type SimulationOptions = {
         video?: boolean;
     };
 };
+export interface SendTextOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    attachments?: Array<File>;
+    onProgress?: (progress: number) => void;
+}
+export interface StreamTextOptions {
+    topic?: string;
+    destinationIdentities?: Array<string>;
+    type?: 'create' | 'update';
+    streamId?: string;
+    version?: number;
+    attachedStreamIds?: Array<string>;
+    replyToStreamId?: string;
+    totalSize?: number;
+}
 export type DataPublishOptions = {
     /**
      * whether to send this as reliable or lossy.
@@ -50,5 +67,31 @@ export interface ChatMessage {
     timestamp: number;
     message: string;
     editTimestamp?: number;
+    attachedFiles?: Array<File>;
+}
+export interface StreamController<T extends DataStream_Chunk> {
+    info: BaseStreamInfo;
+    controller: ReadableStreamDefaultController<T>;
+    startTime: number;
+    endTime?: number;
 }
+export interface BaseStreamInfo {
+    id: string;
+    mimeType: string;
+    topic: string;
+    timestamp: number;
+    /** total size in bytes for finite streams and undefined for streams of unknown size */
+    size?: number;
+    attributes?: Record<string, string>;
+}
+export interface ByteStreamInfo extends BaseStreamInfo {
+    name: string;
+}
+export interface TextStreamInfo extends BaseStreamInfo {
+}
+export type TextStreamChunk = {
+    index: number;
+    current: string;
+    collected: string;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/ts4.2/src/room/utils.d.ts

@@ -1,7 +1,18 @@
 import { ChatMessage as ChatMessageModel, ClientInfo, DisconnectReason, Transcription as TranscriptionModel } from '@livekit/protocol';
 import type { ConnectionError } from './errors';
+import type LocalParticipant from './participant/LocalParticipant';
+import type Participant from './participant/Participant';
+import type RemoteParticipant from './participant/RemoteParticipant';
 import type LocalAudioTrack from './track/LocalAudioTrack';
+import type LocalTrack from './track/LocalTrack';
+import type LocalTrackPublication from './track/LocalTrackPublication';
+import type LocalVideoTrack from './track/LocalVideoTrack';
 import type RemoteAudioTrack from './track/RemoteAudioTrack';
+import type RemoteTrack from './track/RemoteTrack';
+import type RemoteTrackPublication from './track/RemoteTrackPublication';
+import type RemoteVideoTrack from './track/RemoteVideoTrack';
+import { Track } from './track/Track';
+import type { TrackPublication } from './track/TrackPublication';
 import type { VideoCodec } from './track/options';
 import type { ChatMessage, TranscriptionSegment } from './types';
 export declare const ddExtensionURI = "https://aomediacodec.github.io/av1-rtp-spec/#dependency-descriptor-rtp-header-extension";
@@ -89,4 +100,19 @@ export declare function toHttpUrl(url: string): string;
 export declare function extractTranscriptionSegments(transcription: TranscriptionModel, firstReceivedTimesMap: Map<string, number>): TranscriptionSegment[];
 export declare function extractChatMessage(msg: ChatMessageModel): ChatMessage;
 export declare function getDisconnectReasonFromConnectionError(e: ConnectionError): DisconnectReason;
+/** convert bigints to numbers preserving undefined values */
+export declare function bigIntToNumber<T extends BigInt | undefined>(value: T): T extends BigInt ? number : undefined;
+/** convert numbers to bigints preserving undefined values */
+export declare function numberToBigInt<T extends number | undefined>(value: T): T extends number ? bigint : undefined;
+export declare function isLocalTrack(track: Track | MediaStreamTrack | undefined): track is LocalTrack;
+export declare function isAudioTrack(track: Track | undefined): track is LocalAudioTrack | RemoteAudioTrack;
+export declare function isVideoTrack(track: Track | undefined): track is LocalVideoTrack | RemoteVideoTrack;
+export declare function isLocalVideoTrack(track: Track | MediaStreamTrack | undefined): track is LocalVideoTrack;
+export declare function isLocalAudioTrack(track: Track | MediaStreamTrack | undefined): track is LocalAudioTrack;
+export declare function isRemoteTrack(track: Track | undefined): track is RemoteTrack;
+export declare function isRemotePub(pub: TrackPublication | undefined): pub is RemoteTrackPublication;
+export declare function isLocalPub(pub: TrackPublication | undefined): pub is LocalTrackPublication;
+export declare function isRemoteVideoTrack(track: Track | undefined): track is RemoteVideoTrack;
+export declare function isLocalParticipant(p: Participant): p is LocalParticipant;
+export declare function isRemoteParticipant(p: Participant): p is RemoteParticipant;
 //# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livekit-client",
-  "version": "2.8.1",
+  "version": "2.9.1",
   "description": "JavaScript/TypeScript client SDK for LiveKit",
   "main": "./dist/livekit-client.umd.js",
   "unpkg": "./dist/livekit-client.umd.js",
@@ -37,7 +37,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@livekit/mutex": "1.1.1",
-    "@livekit/protocol": "1.30.0",
+    "@livekit/protocol": "1.33.0",
     "events": "^3.3.0",
     "loglevel": "^1.8.0",
     "sdp-transform": "^2.14.1",
@@ -81,7 +81,7 @@
     "typedoc": "0.27.6",
     "typedoc-plugin-no-inherit": "1.4.0",
     "typescript": "5.7.2",
-    "vite": "5.4.11",
+    "vite": "5.4.12",
     "vitest": "^1.0.0"
   },
   "scripts": {

package/src/api/SignalClient.ts

@@ -294,7 +294,10 @@ export class SignalClient {
           abortHandler();
         }
         abortSignal?.addEventListener('abort', abortHandler);
-        this.log.debug(`connecting to ${url + params}`, this.logContext);
+        this.log.debug(
+          `connecting to ${url + params.replace(/access_token=([^&#$]*)/, 'access_token=<redacted>')}`,
+          this.logContext,
+        );
         if (this.ws) {
           await this.close(false);
         }
@@ -326,7 +329,7 @@ export class SignalClient {
             } catch (e) {
               reject(
                 new ConnectionError(
-                  'server was not reachable',
+                  e instanceof Error ? e.message : 'server was not reachable',
                   ConnectionErrorReason.ServerUnreachable,
                 ),
               );

package/src/e2ee/E2eeManager.ts

@@ -7,11 +7,11 @@ import type Room from '../room/Room';
 import { ConnectionState } from '../room/Room';
 import { DeviceUnsupportedError } from '../room/errors';
 import { EngineEvent, ParticipantEvent, RoomEvent } from '../room/events';
-import LocalTrack from '../room/track/LocalTrack';
 import type RemoteTrack from '../room/track/RemoteTrack';
 import type { Track } from '../room/track/Track';
 import type { VideoCodec } from '../room/track/options';
 import { mimeTypeToVideoCodecString } from '../room/track/utils';
+import { isLocalTrack } from '../room/utils';
 import type { BaseKeyProvider } from './KeyProvider';
 import { E2EE_FLAG } from './constants';
 import { type E2EEManagerCallbacks, EncryptionEvent, KeyProviderEvent } from './events';
@@ -317,7 +317,7 @@ export class E2EEManager
   }
 
   private setupE2EESender(track: Track, sender: RTCRtpSender) {
-    if (!(track instanceof LocalTrack) || !sender) {
+    if (!isLocalTrack(track) || !sender) {
       if (!sender) log.warn('early return because sender is not ready');
       return;
     }

package/src/index.ts

@@ -1,5 +1,5 @@
 import { Mutex } from '@livekit/mutex';
-import { DataPacket_Kind, DisconnectReason, SubscriptionError } from '@livekit/protocol';
+import { DataPacket_Kind, DisconnectReason, SubscriptionError, TrackType } from '@livekit/protocol';
 import { LogLevel, LoggerNames, getLogger, setLogExtension, setLogLevel } from './logger';
 import DefaultReconnectPolicy from './room/DefaultReconnectPolicy';
 import type { ReconnectContext, ReconnectPolicy } from './room/ReconnectPolicy';
@@ -32,7 +32,13 @@ import {
   createAudioAnalyser,
   getEmptyAudioStreamTrack,
   getEmptyVideoStreamTrack,
+  isAudioTrack,
   isBrowserSupported,
+  isLocalParticipant,
+  isLocalTrack,
+  isRemoteParticipant,
+  isRemoteTrack,
+  isVideoTrack,
   supportsAV1,
   supportsAdaptiveStream,
   supportsDynacast,
@@ -55,11 +61,14 @@ export { facingModeFromDeviceLabel, facingModeFromLocalTrack } from './room/trac
 export * from './room/track/options';
 export * from './room/track/processor/types';
 export * from './room/track/types';
+export type * from './room/StreamReader';
+export type * from './room/StreamWriter';
 export type {
   DataPublishOptions,
   SimulationScenario,
   TranscriptionSegment,
   ChatMessage,
+  SendTextOptions,
 } from './room/types';
 export * from './version';
 export {
@@ -100,6 +109,12 @@ export {
   supportsDynacast,
   supportsVP9,
   Mutex,
+  isAudioTrack,
+  isLocalTrack,
+  isRemoteTrack,
+  isVideoTrack,
+  isLocalParticipant,
+  isRemoteParticipant,
 };
 export type {
   AudioAnalyserOptions,
@@ -112,4 +127,5 @@ export type {
   VideoSenderStats,
   ReconnectContext,
   ReconnectPolicy,
+  TrackType,
 };

package/src/room/RTCEngine.ts

@@ -16,6 +16,8 @@ import {
   type ReconnectResponse,
   RequestResponse,
   Room as RoomModel,
+  RpcAck,
+  RpcResponse,
   SignalTarget,
   SpeakerInfo,
   type StreamStateUpdate,
@@ -54,6 +56,7 @@ import {
   UnexpectedConnectionState,
 } from './errors';
 import { EngineEvent } from './events';
+import { RpcError } from './rpc';
 import CriticalTimers from './timers';
 import type LocalTrack from './track/LocalTrack';
 import type LocalTrackPublication from './track/LocalTrackPublication';
@@ -64,7 +67,14 @@ import type { Track } from './track/Track';
 import type { TrackPublishOptions, VideoCodec } from './track/options';
 import { getTrackPublicationInfo } from './track/utils';
 import type { LoggerOptions } from './types';
-import { isVideoCodec, isWeb, sleep, supportsAddTrack, supportsTransceiver } from './utils';
+import {
+  isVideoCodec,
+  isVideoTrack,
+  isWeb,
+  sleep,
+  supportsAddTrack,
+  supportsTransceiver,
+} from './utils';
 
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
@@ -657,6 +667,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         return;
       }
       const dp = DataPacket.fromBinary(new Uint8Array(buffer));
+
       if (dp.value?.case === 'speaker') {
         // dispatch speaker updates
         this.emit(EngineEvent.ActiveSpeakersUpdate, dp.value.value.speakers);
@@ -745,7 +756,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       streams.push(track.mediaStream);
     }
 
-    if (track instanceof LocalVideoTrack) {
+    if (isVideoTrack(track)) {
       track.codec = opts.videoCodec;
     }
 
@@ -1089,6 +1100,46 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     });
   };
 
+  /** @internal */
+  async publishRpcResponse(
+    destinationIdentity: string,
+    requestId: string,
+    payload: string | null,
+    error: RpcError | null,
+  ) {
+    const packet = new DataPacket({
+      destinationIdentities: [destinationIdentity],
+      kind: DataPacket_Kind.RELIABLE,
+      value: {
+        case: 'rpcResponse',
+        value: new RpcResponse({
+          requestId,
+          value: error
+            ? { case: 'error', value: error.toProto() }
+            : { case: 'payload', value: payload ?? '' },
+        }),
+      },
+    });
+
+    await this.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+  }
+
+  /** @internal */
+  async publishRpcAck(destinationIdentity: string, requestId: string) {
+    const packet = new DataPacket({
+      destinationIdentities: [destinationIdentity],
+      kind: DataPacket_Kind.RELIABLE,
+      value: {
+        case: 'rpcAck',
+        value: new RpcAck({
+          requestId,
+        }),
+      },
+    });
+
+    await this.sendDataPacket(packet, DataPacket_Kind.RELIABLE);
+  }
+
   /* @internal */
   async sendDataPacket(packet: DataPacket, kind: DataPacket_Kind) {
     const msg = packet.toBinary();
@@ -1119,6 +1170,22 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     }
   };
 
+  waitForBufferStatusLow(kind: DataPacket_Kind): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+      if (this.isBufferStatusLow(kind)) {
+        resolve();
+      } else {
+        const onClosing = () => reject('Engine closed');
+        this.once(EngineEvent.Closing, onClosing);
+        while (!this.dcBufferStatus.get(kind)) {
+          await sleep(10);
+        }
+        this.off(EngineEvent.Closing, onClosing);
+        resolve();
+      }
+    });
+  }
+
   /**
    * @internal
    */