livekit-server-sdk 2.9.3 → 2.9.4

package/dist/IngressClient.d.cts

@@ -0,0 +1,136 @@
+import { IngressAudioOptions, IngressVideoOptions, IngressInput, IngressInfo } from '@livekit/protocol';
+import { ServiceBase } from './ServiceBase.cjs';
+import './grants.cjs';
+import 'jose';
+
+interface CreateIngressOptions {
+    /**
+     * ingress name. optional
+     */
+    name?: string;
+    /**
+     * name of the room to send media to. required
+     */
+    roomName?: string;
+    /**
+     * unique identity of the participant. required
+     */
+    participantIdentity: string;
+    /**
+     * participant display name
+     */
+    participantName?: string;
+    /**
+     * metadata to attach to the participant
+     */
+    participantMetadata?: string;
+    /**
+     * @deprecated use `enableTranscoding` instead.
+     * whether to skip transcoding and forward the input media directly. Only supported by WHIP
+     */
+    bypassTranscoding?: boolean;
+    /**
+     * whether to enable transcoding or forward the input media directly.
+     * Transcoding is required for all input types except WHIP. For WHIP, the default is to not transcode.
+     */
+    enableTranscoding?: boolean | undefined;
+    /**
+     * url of the media to pull for ingresses of type URL
+     */
+    url?: string;
+    /**
+     * custom audio encoding parameters. optional
+     */
+    audio?: IngressAudioOptions;
+    /**
+     * custom video encoding parameters. optional
+     */
+    video?: IngressVideoOptions;
+}
+interface UpdateIngressOptions {
+    /**
+     * ingress name. optional
+     */
+    name: string;
+    /**
+     * name of the room to send media to.
+     */
+    roomName?: string;
+    /**
+     * unique identity of the participant.
+     */
+    participantIdentity?: string;
+    /**
+     * participant display name
+     */
+    participantName?: string;
+    /**
+     * metadata to attach to the participant
+     */
+    participantMetadata?: string;
+    /**
+     * @deprecated use `enableTranscoding` instead
+     * whether to skip transcoding and forward the input media directly. Only supported by WHIP
+     */
+    bypassTranscoding?: boolean | undefined;
+    /**
+     * whether to enable transcoding or forward the input media directly.
+     * Transcoding is required for all input types except WHIP. For WHIP, the default is to not transcode.
+     */
+    enableTranscoding?: boolean | undefined;
+    /**
+     * custom audio encoding parameters. optional
+     */
+    audio?: IngressAudioOptions;
+    /**
+     * custom video encoding parameters. optional
+     */
+    video?: IngressVideoOptions;
+}
+interface ListIngressOptions {
+    /**
+     * list ingress for one room only
+     */
+    roomName?: string;
+    /**
+     * list ingress by ID
+     */
+    ingressId?: string;
+}
+/**
+ * Client to access Ingress APIs
+ */
+declare class IngressClient extends ServiceBase {
+    private readonly rpc;
+    /**
+     * @param host - hostname including protocol. i.e. 'https://<project>.livekit.cloud'
+     * @param apiKey - API Key, can be set in env var LIVEKIT_API_KEY
+     * @param secret - API Secret, can be set in env var LIVEKIT_API_SECRET
+     */
+    constructor(host: string, apiKey?: string, secret?: string);
+    /**
+     * @param inputType - protocol for the ingress
+     * @param opts - CreateIngressOptions
+     */
+    createIngress(inputType: IngressInput, opts: CreateIngressOptions): Promise<IngressInfo>;
+    /**
+     * @param ingressId - ID of the ingress to update
+     * @param opts - UpdateIngressOptions
+     */
+    updateIngress(ingressId: string, opts: UpdateIngressOptions): Promise<IngressInfo>;
+    /**
+     * @deprecated use `listIngress(opts)` or `listIngress(arg)` instead
+     * @param roomName - list ingress for one room only
+     */
+    listIngress(roomName?: string): Promise<Array<IngressInfo>>;
+    /**
+     * @param opts - list options
+     */
+    listIngress(opts?: ListIngressOptions): Promise<Array<IngressInfo>>;
+    /**
+     * @param ingressId - ingress to delete
+     */
+    deleteIngress(ingressId: string): Promise<IngressInfo>;
+}
+
+export { type CreateIngressOptions, IngressClient, type ListIngressOptions, type UpdateIngressOptions };

package/dist/RoomServiceClient.d.cts

@@ -0,0 +1,173 @@
+import { RoomEgress, ParticipantPermission, Room, ParticipantInfo, TrackInfo, DataPacket_Kind } from '@livekit/protocol';
+import { ServiceBase } from './ServiceBase.cjs';
+import './grants.cjs';
+import 'jose';
+
+/**
+ * Options for when creating a room
+ */
+interface CreateOptions {
+    /**
+     * name of the room. required
+     */
+    name: string;
+    /**
+     * number of seconds to keep the room open before any participant joins
+     */
+    emptyTimeout?: number;
+    /**
+     * number of seconds to keep the room open after the last participant leaves
+     * this option is helpful to give a grace period for participants to re-join
+     */
+    departureTimeout?: number;
+    /**
+     * limit to the number of participants in a room at a time
+     */
+    maxParticipants?: number;
+    /**
+     * initial room metadata
+     */
+    metadata?: string;
+    /**
+     * add egress options
+     */
+    egress?: RoomEgress;
+    /**
+     * minimum playout delay in milliseconds
+     */
+    minPlayoutDelay?: number;
+    /**
+     * maximum playout delay in milliseconds
+     */
+    maxPlayoutDelay?: number;
+    /**
+     * improves A/V sync when min_playout_delay set to a value larger than 200ms.
+     * It will disables transceiver re-use -- this option is not recommended
+     * for rooms with frequent subscription changes
+     */
+    syncStreams?: boolean;
+    /**
+     * override the node room is allocated to, for debugging
+     * does not work with Cloud
+     */
+    nodeId?: string;
+}
+type SendDataOptions = {
+    /** If set, only deliver to listed participant identities */
+    destinationIdentities?: string[];
+    destinationSids?: string[];
+    topic?: string;
+};
+type UpdateParticipantOptions = {
+    /** only attributes you'd want to update should be set, set value to empty string to remove it */
+    attributes?: {
+        [key: string]: string;
+    };
+    metadata?: string;
+    /** permissions are updated atomically - all desired permissions would need to be set */
+    permission?: Partial<ParticipantPermission>;
+    name?: string;
+};
+/**
+ * Client to access Room APIs
+ */
+declare class RoomServiceClient extends ServiceBase {
+    private readonly rpc;
+    /**
+     *
+     * @param host - hostname including protocol. i.e. 'https://<project>.livekit.cloud'
+     * @param apiKey - API Key, can be set in env var LIVEKIT_API_KEY
+     * @param secret - API Secret, can be set in env var LIVEKIT_API_SECRET
+     */
+    constructor(host: string, apiKey?: string, secret?: string);
+    /**
+     * Creates a new room. Explicit room creation is not required, since rooms will
+     * be automatically created when the first participant joins. This method can be
+     * used to customize room settings.
+     * @param options -
+     */
+    createRoom(options: CreateOptions): Promise<Room>;
+    /**
+     * List active rooms
+     * @param names - when undefined or empty, list all rooms.
+     *                otherwise returns rooms with matching names
+     * @returns
+     */
+    listRooms(names?: string[]): Promise<Room[]>;
+    deleteRoom(room: string): Promise<void>;
+    /**
+     * Update metadata of a room
+     * @param room - name of the room
+     * @param metadata - the new metadata for the room
+     */
+    updateRoomMetadata(room: string, metadata: string): Promise<Room>;
+    /**
+     * List participants in a room
+     * @param room - name of the room
+     */
+    listParticipants(room: string): Promise<ParticipantInfo[]>;
+    /**
+     * Get information on a specific participant, including the tracks that participant
+     * has published
+     * @param room - name of the room
+     * @param identity - identity of the participant to return
+     */
+    getParticipant(room: string, identity: string): Promise<ParticipantInfo>;
+    /**
+     * Removes a participant in the room. This will disconnect the participant
+     * and will emit a Disconnected event for that participant.
+     * Even after being removed, the participant can still re-join the room.
+     * @param room -
+     * @param identity -
+     */
+    removeParticipant(room: string, identity: string): Promise<void>;
+    /**
+     * Mutes a track that the participant has published.
+     * @param room -
+     * @param identity -
+     * @param trackSid - sid of the track to be muted
+     * @param muted - true to mute, false to unmute
+     */
+    mutePublishedTrack(room: string, identity: string, trackSid: string, muted: boolean): Promise<TrackInfo>;
+    /**
+     * Updates a participant's state or permissions
+     * @param room - target room
+     * @param identity - participant identity
+     * @param options - participant fields to update
+     */
+    updateParticipant(room: string, identity: string, options: UpdateParticipantOptions): Promise<ParticipantInfo>;
+    /**
+     * Updates a participant's state or permissions
+     * @param room - target room
+     * @param identity - participant identity
+     * @param options - participant fields to update
+     */
+    updateParticipant(room: string, identity: string, metadata?: string, permission?: Partial<ParticipantPermission>, name?: string): Promise<ParticipantInfo>;
+    /**
+     * Updates a participant's subscription to tracks
+     * @param room -
+     * @param identity -
+     * @param trackSids -
+     * @param subscribe - true to subscribe, false to unsubscribe
+     */
+    updateSubscriptions(room: string, identity: string, trackSids: string[], subscribe: boolean): Promise<void>;
+    /**
+     * Sends data message to participants in the room
+     * @param room -
+     * @param data - opaque payload to send
+     * @param kind - delivery reliability
+     * @param options - optionally specify a topic and destinationSids (when destinationSids is empty, message is sent to everyone)
+     */
+    sendData(room: string, data: Uint8Array, kind: DataPacket_Kind, options: SendDataOptions): Promise<void>;
+    /**
+     * Sends data message to participants in the room
+     * @deprecated use sendData(room, data, kind, options) instead
+     * @param room -
+     * @param data - opaque payload to send
+     * @param kind - delivery reliability
+     * @param destinationSids - optional. when empty, message is sent to everyone
+     */
+    sendData(room: string, data: Uint8Array, kind: DataPacket_Kind, destinationSids?: string[]): Promise<void>;
+}
+
+export { type CreateOptions, RoomServiceClient, type SendDataOptions, type UpdateParticipantOptions };

package/dist/ServiceBase.d.cts

@@ -0,0 +1,21 @@
+import { VideoGrant, SIPGrant } from './grants.cjs';
+import '@livekit/protocol';
+import 'jose';
+
+/**
+ * Utilities to handle authentication
+ */
+declare class ServiceBase {
+    private readonly apiKey?;
+    private readonly secret?;
+    private readonly ttl;
+    /**
+     * @param apiKey - API Key.
+     * @param secret - API Secret.
+     * @param ttl - token TTL
+     */
+    constructor(apiKey?: string, secret?: string, ttl?: string);
+    authHeader(grant: VideoGrant, sip?: SIPGrant): Promise<Record<string, string>>;
+}
+
+export { ServiceBase };

package/dist/SipClient.d.cts

@@ -0,0 +1,142 @@
+import { SIPTransport, SIPTrunkInfo, SIPInboundTrunkInfo, SIPOutboundTrunkInfo, SIPDispatchRuleInfo, SIPParticipantInfo } from '@livekit/protocol';
+import { ServiceBase } from './ServiceBase.cjs';
+import './grants.cjs';
+import 'jose';
+
+/**
+ * @deprecated use CreateSipInboundTrunkOptions or CreateSipOutboundTrunkOptions
+ */
+interface CreateSipTrunkOptions {
+    name?: string;
+    metadata?: string;
+    inbound_addresses?: string[];
+    inbound_numbers?: string[];
+    inbound_username?: string;
+    inbound_password?: string;
+    outbound_address?: string;
+    outbound_username?: string;
+    outbound_password?: string;
+}
+interface CreateSipInboundTrunkOptions {
+    metadata?: string;
+    allowed_addresses?: string[];
+    allowed_numbers?: string[];
+    auth_username?: string;
+    auth_password?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    headersToAttributes?: {
+        [key: string]: string;
+    };
+}
+interface CreateSipOutboundTrunkOptions {
+    metadata?: string;
+    transport: SIPTransport;
+    auth_username?: string;
+    auth_password?: string;
+    headers?: {
+        [key: string]: string;
+    };
+    headersToAttributes?: {
+        [key: string]: string;
+    };
+}
+interface SipDispatchRuleDirect {
+    type: 'direct';
+    roomName: string;
+    pin?: string;
+}
+interface SipDispatchRuleIndividual {
+    type: 'individual';
+    roomPrefix: string;
+    pin?: string;
+}
+interface CreateSipDispatchRuleOptions {
+    name?: string;
+    metadata?: string;
+    trunkIds?: string[];
+    hidePhoneNumber?: boolean;
+}
+interface CreateSipParticipantOptions {
+    participantIdentity?: string;
+    participantName?: string;
+    participantMetadata?: string;
+    dtmf?: string;
+    /** @deprecated - use `playDialtone` instead */
+    playRingtone?: boolean;
+    playDialtone?: boolean;
+    hidePhoneNumber?: boolean;
+    ringingTimeout?: number;
+    maxCallDuration?: number;
+    enableKrisp?: boolean;
+}
+interface TransferSipParticipantOptions {
+    playDialtone?: boolean;
+}
+/**
+ * Client to access Egress APIs
+ */
+declare class SipClient extends ServiceBase {
+    private readonly rpc;
+    /**
+     * @param host - hostname including protocol. i.e. 'https://<project>.livekit.cloud'
+     * @param apiKey - API Key, can be set in env var LIVEKIT_API_KEY
+     * @param secret - API Secret, can be set in env var LIVEKIT_API_SECRET
+     */
+    constructor(host: string, apiKey?: string, secret?: string);
+    /**
+     * @param number - phone number of the trunk
+     * @param opts - CreateSipTrunkOptions
+     * @deprecated use `createSipInboundTrunk` or `createSipOutboundTrunk`
+     */
+    createSipTrunk(number: string, opts?: CreateSipTrunkOptions): Promise<SIPTrunkInfo>;
+    /**
+     * @param name - human-readable name of the trunk
+     * @param numbers - phone numbers of the trunk
+     * @param opts - CreateSipTrunkOptions
+     */
+    createSipInboundTrunk(name: string, numbers: string[], opts?: CreateSipInboundTrunkOptions): Promise<SIPInboundTrunkInfo>;
+    /**
+     * @param name - human-readable name of the trunk
+     * @param address - hostname and port of the SIP server to dial
+     * @param numbers - phone numbers of the trunk
+     * @param opts - CreateSipTrunkOptions
+     */
+    createSipOutboundTrunk(name: string, address: string, numbers: string[], opts?: CreateSipOutboundTrunkOptions): Promise<SIPOutboundTrunkInfo>;
+    /**
+     * @deprecated use `listSipInboundTrunk` or `listSipOutboundTrunk`
+     */
+    listSipTrunk(): Promise<Array<SIPTrunkInfo>>;
+    listSipInboundTrunk(): Promise<Array<SIPInboundTrunkInfo>>;
+    listSipOutboundTrunk(): Promise<Array<SIPOutboundTrunkInfo>>;
+    /**
+     * @param sipTrunkId - sip trunk to delete
+     */
+    deleteSipTrunk(sipTrunkId: string): Promise<SIPTrunkInfo>;
+    /**
+     * @param rule - sip dispatch rule
+     * @param opts - CreateSipDispatchRuleOptions
+     */
+    createSipDispatchRule(rule: SipDispatchRuleDirect | SipDispatchRuleIndividual, opts?: CreateSipDispatchRuleOptions): Promise<SIPDispatchRuleInfo>;
+    listSipDispatchRule(): Promise<Array<SIPDispatchRuleInfo>>;
+    /**
+     * @param sipDispatchRuleId - sip trunk to delete
+     */
+    deleteSipDispatchRule(sipDispatchRuleId: string): Promise<SIPDispatchRuleInfo>;
+    /**
+     * @param sipTrunkId - sip trunk to use for the call
+     * @param number - number to dial
+     * @param roomName - room to attach the call to
+     * @param opts - CreateSipParticipantOptions
+     */
+    createSipParticipant(sipTrunkId: string, number: string, roomName: string, opts?: CreateSipParticipantOptions): Promise<SIPParticipantInfo>;
+    /**
+     * @param roomName - room the SIP participant to transfer is connectd to
+     * @param participantIdentity - identity of the SIP participant to transfer
+     * @param transferTo - SIP URL to transfer the participant to
+     */
+    transferSipParticipant(roomName: string, participantIdentity: string, transferTo: string, opts?: TransferSipParticipantOptions): Promise<void>;
+}
+
+export { type CreateSipDispatchRuleOptions, type CreateSipInboundTrunkOptions, type CreateSipOutboundTrunkOptions, type CreateSipParticipantOptions, type CreateSipTrunkOptions, SipClient, type SipDispatchRuleDirect, type SipDispatchRuleIndividual, type TransferSipParticipantOptions };

package/dist/TwirpRPC.d.cts

@@ -0,0 +1,18 @@
+import { JsonValue } from '@bufbuild/protobuf';
+
+declare const livekitPackage = "livekit";
+interface Rpc {
+    request(service: string, method: string, data: JsonValue, headers?: any): Promise<string>;
+}
+/**
+ * JSON based Twirp V7 RPC
+ */
+declare class TwirpRpc {
+    host: string;
+    pkg: string;
+    prefix: string;
+    constructor(host: string, pkg: string, prefix?: string);
+    request(service: string, method: string, data: any, headers?: any): Promise<any>;
+}
+
+export { type Rpc, TwirpRpc, livekitPackage };

package/dist/WebhookReceiver.d.cts

@@ -0,0 +1,29 @@
+import { BinaryReadOptions, JsonValue, JsonReadOptions } from '@bufbuild/protobuf';
+import { WebhookEvent as WebhookEvent$1 } from '@livekit/protocol';
+
+declare const authorizeHeader = "Authorize";
+declare class WebhookEvent extends WebhookEvent$1 {
+    event: WebhookEventNames;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): WebhookEvent;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): WebhookEvent;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): WebhookEvent;
+}
+type WebhookEventNames = 'room_started' | 'room_finished' | 'participant_joined' | 'participant_left' | 'track_published' | 'track_unpublished' | 'egress_started' | 'egress_updated' | 'egress_ended' | 'ingress_started' | 'ingress_ended'
+/**
+ * @internal
+ * @remarks only used as a default value, not a valid webhook event
+ */
+ | '';
+declare class WebhookReceiver {
+    private verifier;
+    constructor(apiKey: string, apiSecret: string);
+    /**
+     * @param body - string of the posted body
+     * @param authHeader - `Authorization` header from the request
+     * @param skipAuth - true to skip auth validation
+     * @returns
+     */
+    receive(body: string, authHeader?: string, skipAuth?: boolean): Promise<WebhookEvent>;
+}
+
+export { WebhookEvent, type WebhookEventNames, WebhookReceiver, authorizeHeader };

package/dist/digest.d.cts

@@ -0,0 +1,3 @@
+declare function digest(data: string): Promise<ArrayBuffer>;
+
+export { digest as default };

package/dist/grants.d.cts

@@ -0,0 +1,71 @@
+import { TrackSource, RoomConfiguration } from '@livekit/protocol';
+import { JWTPayload } from 'jose';
+
+declare function trackSourceToString(source: TrackSource): "camera" | "microphone" | "screen_share" | "screen_share_audio";
+declare function claimsToJwtPayload(grant: ClaimGrants): JWTPayload & {
+    video?: Record<string, unknown>;
+};
+interface VideoGrant {
+    /** permission to create a room */
+    roomCreate?: boolean;
+    /** permission to join a room as a participant, room must be set */
+    roomJoin?: boolean;
+    /** permission to list rooms */
+    roomList?: boolean;
+    /** permission to start a recording */
+    roomRecord?: boolean;
+    /** permission to control a specific room, room must be set */
+    roomAdmin?: boolean;
+    /** name of the room, must be set for admin or join permissions */
+    room?: string;
+    /** permissions to control ingress, not specific to any room or ingress */
+    ingressAdmin?: boolean;
+    /**
+     * allow participant to publish. If neither canPublish or canSubscribe is set,
+     * both publish and subscribe are enabled
+     */
+    canPublish?: boolean;
+    /**
+     * TrackSource types that the participant is allowed to publish
+     * When set, it supersedes CanPublish. Only sources explicitly set here can be published
+     */
+    canPublishSources?: TrackSource[];
+    /** allow participant to subscribe to other tracks */
+    canSubscribe?: boolean;
+    /**
+     * allow participants to publish data, defaults to true if not set
+     */
+    canPublishData?: boolean;
+    /**
+     * by default, a participant is not allowed to update its own metadata
+     */
+    canUpdateOwnMetadata?: boolean;
+    /** participant isn't visible to others */
+    hidden?: boolean;
+    /** participant is recording the room, when set, allows room to indicate it's being recorded */
+    recorder?: boolean;
+    /** participant allowed to connect to LiveKit as Agent Framework worker */
+    agent?: boolean;
+    /** allow participant to subscribe to metrics */
+    canSubscribeMetrics?: boolean;
+}
+interface SIPGrant {
+    /** manage sip resources */
+    admin?: boolean;
+    /** make outbound calls */
+    call?: boolean;
+}
+/** @internal */
+interface ClaimGrants extends JWTPayload {
+    name?: string;
+    video?: VideoGrant;
+    sip?: SIPGrant;
+    kind?: string;
+    metadata?: string;
+    attributes?: Record<string, string>;
+    sha256?: string;
+    roomPreset?: string;
+    roomConfig?: RoomConfiguration;
+}
+
+export { type ClaimGrants, type SIPGrant, type VideoGrant, claimsToJwtPayload, trackSourceToString };

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+export { AliOSSUpload, AutoParticipantEgress, AutoTrackEgress, AzureBlobUpload, DataPacket_Kind, DirectFileOutput, EgressInfo, EgressStatus, EncodedFileOutput, EncodedFileType, EncodingOptions, EncodingOptionsPreset, GCPUpload, ImageCodec, ImageFileSuffix, ImageOutput, IngressAudioEncodingOptions, IngressAudioEncodingPreset, IngressAudioOptions, IngressInfo, IngressInput, IngressState, IngressVideoEncodingOptions, IngressVideoEncodingPreset, IngressVideoOptions, ParticipantEgressRequest, ParticipantInfo, ParticipantInfo_State, ParticipantPermission, Room, RoomCompositeEgressRequest, RoomEgress, S3Upload, SIPDispatchRuleInfo, SIPParticipantInfo, SIPTrunkInfo, SegmentedFileOutput, SegmentedFileProtocol, StreamOutput, StreamProtocol, TrackCompositeEgressRequest, TrackEgressRequest, TrackInfo, TrackSource, TrackType, WebEgressRequest } from '@livekit/protocol';
+export { AccessToken, AccessTokenOptions, TokenVerifier } from './AccessToken.cjs';
+export { AgentDispatchClient } from './AgentDispatchClient.cjs';
+export { EgressClient, EncodedOutputs, ListEgressOptions, ParticipantEgressOptions, RoomCompositeOptions, TrackCompositeOptions, WebOptions } from './EgressClient.cjs';
+export { ClaimGrants, SIPGrant, VideoGrant, claimsToJwtPayload, trackSourceToString } from './grants.cjs';
+export { CreateIngressOptions, IngressClient, ListIngressOptions, UpdateIngressOptions } from './IngressClient.cjs';
+export { CreateOptions, RoomServiceClient, SendDataOptions, UpdateParticipantOptions } from './RoomServiceClient.cjs';
+export { CreateSipDispatchRuleOptions, CreateSipInboundTrunkOptions, CreateSipOutboundTrunkOptions, CreateSipParticipantOptions, CreateSipTrunkOptions, SipClient, SipDispatchRuleDirect, SipDispatchRuleIndividual, TransferSipParticipantOptions } from './SipClient.cjs';
+export { WebhookEvent, WebhookEventNames, WebhookReceiver, authorizeHeader } from './WebhookReceiver.cjs';
+import './ServiceBase.cjs';
+import 'jose';
+import '@bufbuild/protobuf';

package/package.json

@@ -1,19 +1,27 @@
 {
   "name": "livekit-server-sdk",
-  "version": "2.9.3",
+  "version": "2.9.4",
   "description": "Server-side SDK for LiveKit",
   "main": "dist/index.js",
   "require": "dist/index.cjs",
   "types": "dist/index.d.ts",
-  "repository": "git@github.com:livekit/server-sdk-js.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/livekit/server-sdk-js.git"
+  },
   "author": "David Zhao <david@davidzhao.com>",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
   "files": [

package/src/AccessToken.test.ts

@@ -9,8 +9,8 @@ import {
 } from '@livekit/protocol';
 import * as jose from 'jose';
 import { describe, expect, it } from 'vitest';
-import { AccessToken, TokenVerifier } from './AccessToken';
-import type { ClaimGrants } from './grants';
+import { AccessToken, TokenVerifier } from './AccessToken.js';
+import type { ClaimGrants } from './grants.js';
 
 const testApiKey = 'abcdefg';
 const testSecret = 'abababa';
@@ -143,10 +143,10 @@ describe('room configuration with agents and egress', () => {
     expect(decoded.roomConfig?.name).toEqual('test-room');
     expect(decoded.roomConfig?.maxParticipants).toEqual(10);
     expect(decoded.roomConfig?.agents).toHaveLength(2);
-    expect(decoded.roomConfig?.agents?.[0].agentName).toEqual('agent1');
-    expect(decoded.roomConfig?.agents?.[0].metadata).toEqual('metadata-1');
-    expect(decoded.roomConfig?.agents?.[1].agentName).toEqual('agent2');
-    expect(decoded.roomConfig?.agents?.[1].metadata).toEqual('metadata-2');
+    expect(decoded.roomConfig?.agents?.[0]?.agentName).toEqual('agent1');
+    expect(decoded.roomConfig?.agents?.[0]?.metadata).toEqual('metadata-1');
+    expect(decoded.roomConfig?.agents?.[1]?.agentName).toEqual('agent2');
+    expect(decoded.roomConfig?.agents?.[1]?.metadata).toEqual('metadata-2');
     expect(decoded.roomConfig?.egress?.room?.roomName).toEqual('test-room');
   });
 });

package/src/EgressClient.ts

@@ -274,6 +274,7 @@ export class EgressClient extends ServiceBase {
     const req = new ParticipantEgressRequest({
       roomName,
       identity,
+      screenShare: opts?.screenShare ?? false,
       options,
       fileOutputs,
       streamOutputs,