@kaltura-sdk/rtc-avatar 1.32.0

package/src/lib/session/EselfSession.d.ts

@@ -0,0 +1,394 @@
+import { GetUserMediaEveObj, UserDevicesType, DeviceType, AudioNrMode } from '@kaltura-sdk/rtc-core';
+import { TinyPubSub } from '@unisphere/core';
+import { SignalingOptions } from '../signaling';
+import { MediaTrackState } from '../connection';
+import { LogsCollectorConfig } from '../utils/logsCollector';
+/**
+ * Simplified ICE candidate data for trickle ICE
+ * Matches the format from test_webrtc.html
+ */
+export type IceCandidateData = {
+    candidate: string | null;
+    sdpMLineIndex: number;
+};
+/**
+ * Options for joining ASR connection.
+ * Extensible for future feature flags.
+ */
+export interface AsrVideoConfig {
+    /** Video width in pixels (default: 640) */
+    width?: number;
+    /** Video height in pixels (default: 480) */
+    height?: number;
+    /** MaxFps: default 25 FPS*/
+    maxFps?: number;
+    /** Content hint for the video track (default: 'detail') */
+    contentHint?: string;
+    /** max bitrate in Kilobits, if not given use browser default */
+    maxBitrateKbps?: number;
+    /** Degradation preference for the video sender (default: 'maintain-resolution') */
+    degradationPreference?: RTCDegradationPreference;
+    /**  Prevent resolution downscaling (default 1.0 = no scaling)  */
+    scaleResolutionDownBy?: number;
+}
+export interface JoinAsrOptions {
+    /** Send the local video track to the ASR backend (default: false) */
+    sendVideo?: boolean;
+    /** Video configuration when sendVideo is true */
+    videoConfig?: AsrVideoConfig;
+}
+/**
+ * Payload for connection state change events emitted by EselfSession.
+ */
+export type ConnectionStateEvent = {
+    connectionId: string;
+    connectionType: 'asr' | 'stv';
+    status: 'connected' | 'reconnecting' | 'failed';
+    attempt?: number;
+    maxAttempts?: number;
+};
+/**
+ * Configuration options for EselfSession
+ */
+export type EselfSessionConfig = {
+    turnServerUrl?: string;
+    turnUsername?: string;
+    turnCredential?: string;
+    forceAsrRelay?: boolean;
+    forceStvRelay?: boolean;
+    initialConstraintsConfig?: {
+        audio?: {
+            echoCancellation?: boolean;
+            autoGainControl?: boolean;
+            noiseReduction?: boolean;
+        };
+        video?: boolean;
+    };
+    asrUrl?: string;
+    stvUrl?: string;
+    srsUrl?: string;
+    srsApp?: string;
+    maxReconnectAttempts?: number;
+    reconnectDelayMs?: number;
+    speakingThreshold?: number;
+    logsConfig?: LogsCollectorConfig;
+    noiseReduction?: {
+        enabled?: boolean;
+        mode?: AudioNrMode;
+        workletBasePath?: string;
+    };
+};
+export declare class EselfSession {
+    onDevicesListChangePS: TinyPubSub<UserDevicesType>;
+    onDeviceChangedPS: TinyPubSub<{
+        type: 'audio' | 'video' | 'audioOutput';
+        deviceId: string;
+        deviceLabel: string;
+        automatic: boolean;
+        previousDevice?: {
+            id: string;
+            label: string;
+        } | undefined;
+    }>;
+    onConnectionStatePS: TinyPubSub<ConnectionStateEvent>;
+    private devicesManager;
+    private coreRTCSession;
+    private logger;
+    private turnServerUrl?;
+    private turnUsername?;
+    private turnCredential?;
+    private readonly forceAsrRelay;
+    private readonly forceStvRelay;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelayMs;
+    private enableTrickleIce;
+    private whepAdapter;
+    private srsAdapter;
+    private srsApp?;
+    private kasAdapter;
+    private stvRemoteUrl?;
+    private domManager;
+    private signalingClient;
+    private asrConnection;
+    private asrSessionId;
+    private asrReconnectAttempts;
+    private asrReconnectAborted;
+    private stvConnection;
+    private stvConnectionId;
+    private stvSessionId;
+    private stvReconnectAttempts;
+    private stvReconnectAborted;
+    private remoteStreams;
+    private streamElementMappings;
+    private defaultVideoElementId;
+    private deviceListChangedUnsubscribe;
+    private deviceChangedUnsubscribe;
+    private deviceDisappearedUnsubscribe;
+    private speakingStateUnsubscribe;
+    private volumeLevelUnsubscribe;
+    private currentSpeakingState;
+    constructor(config?: EselfSessionConfig);
+    init(): Promise<void>;
+    /**
+     * Setup listener for device list changes (when devices are added/removed)
+     */
+    private setupDevicesListChangedListener;
+    /**
+     * Setup listener for manual device changes
+     */
+    private setupDeviceChangedListener;
+    /**
+     * Setup listener for automatic device switching when selected device disappears
+     */
+    private setupDeviceDisappearedListener;
+    getUserMedia(audio?: boolean, video?: boolean, elementId?: string, isDeviceChange?: boolean, videoConfig?: AsrVideoConfig): Promise<{
+        gumResult: GetUserMediaEveObj;
+        stream: MediaStream | null;
+    }>;
+    getUserDevices(): Promise<UserDevicesType>;
+    /**
+     * Cleanup tracked media elements for a specific tracking key
+     * @param trackingKey - The key used to track elements (elementId or 'default')
+     */
+    private cleanupMediaElements;
+    /**
+     * Cleanup all tracked media elements
+     */
+    private cleanupAllMediaElements;
+    onDevicesListChange(callback: () => void): void;
+    /**
+     * Change input or output device (microphone, camera, or speaker)
+     * Wrapper around CoreRTCSession.changeDevice with DOM element updates
+     *
+     * @param deviceType - DeviceType.AudioInput, DeviceType.VideoInput, or DeviceType.AudioOutput
+     * @param deviceId - Device ID from enumerateDevices
+     * @returns Promise<boolean> - Success status
+     */
+    changeDevice(deviceType: DeviceType.AudioInput | DeviceType.VideoInput | DeviceType.AudioOutput, deviceId: string): Promise<boolean>;
+    /**
+     * Subscribe to device change events
+     * Fires when device is manually changed or automatically switched due to device disappearing
+     *
+     * @param callback - Called when device is changed
+     */
+    onDeviceChanged(callback: (event: {
+        type: 'audio' | 'video' | 'audioOutput';
+        deviceId: string;
+        deviceLabel: string;
+        automatic: boolean;
+        previousDevice?: {
+            id: string;
+            label: string;
+        };
+    }) => void): void;
+    /**
+     * Subscribe to connection state changes.
+     * Fires when a peer connection is established (connected), during retry attempts
+     * (reconnecting), or when max retries are exhausted (failed).
+     *
+     * @param callback - Called on each state change
+     */
+    onConnectionState(callback: (event: ConnectionStateEvent) => void): void;
+    /**
+     * Build ICE configuration from TURN settings
+     * @returns IceConfiguration with TURN servers or empty if not configured
+     */
+    private buildIceConfiguration;
+    /**
+     * Join ASR (Audio Speech Recognition) - Publisher connection
+     * Sends local audio stream to ASR service
+     *
+     * @param signalingOptions - Optional signaling configuration (HTTP endpoints or WebSocket callbacks)
+     *                          If not provided and kasAdapter is available, will use kas backend
+     * @param sessionId - Optional session ID for the connection. If not provided, defaults to 'asr'
+     * @throws Error if connection fails or if already connected
+     */
+    joinASR(signalingOptions?: SignalingOptions, sessionId?: string, isReconnect?: boolean, options?: JoinAsrOptions): Promise<void>;
+    /**
+     * Join STV (Streaming Video) - Viewer connection
+     * Receives remote audio/video stream from avatar
+     *
+     * @param videoContainerId - Optional container element ID for video display
+     * @param signalingOptions - Optional signaling configuration (HTTP endpoints or WebSocket callbacks)
+     *                          If not provided and srsAdapter is available, will use SRS backend
+     * @param sessionId - Optional session ID for the connection. If not provided, defaults to 'stv'.
+     *                   For SRS, this becomes the stream name in the WHEP URL.
+     * @throws Error if connection fails or if already connected
+     */
+    joinSTV(videoContainerId?: string, signalingOptions?: SignalingOptions, sessionId?: string, isReconnect?: boolean, stvUrl?: string): Promise<void>;
+    /**
+     * Manually attach a remote stream to a video container
+     * Allows attaching one stream to multiple containers
+     *
+     * @param streamId - ID of the remote stream
+     * @param containerElementId - ID of the container element
+     */
+    attachStreamToElement(streamId: string, containerElementId: string): void;
+    /**
+     * Detach a remote stream from a specific container
+     *
+     * @param streamId - ID of the remote stream
+     * @param containerElementId - ID of the container element
+     */
+    detachStreamFromElement(streamId: string, containerElementId: string): void;
+    /**
+     * Add a remote ICE candidate to the ASR connection (for trickle ICE)
+     * Accepts simplified format: { candidate: string, sdpMLineIndex: number }
+     *
+     * @param candidate - ICE candidate data received from server (only candidate and sdpMLineIndex)
+     * @throws Error if ASR connection is not active
+     */
+    addRemoteIceCandidate(candidate: IceCandidateData): Promise<void>;
+    /**
+     * Leave ASR connection
+     * Closes the ASR peer connection and cleans up all streams and tracks
+     */
+    leaveASR(): void;
+    /**
+     * Leave STV connection
+     * Closes the STV peer connection and cleans up remote streams
+     */
+    leaveSTV(): void;
+    /**
+     * Private method to handle ASR reconnection logic.
+     * Uses instance fields for state (reconnectAttempts, reconnectAborted, asrSessionId).
+     *
+     * @param connectionId - Connection ID that failed
+     * @param error - Error that caused the failure
+     * @param state - Minimal reconnection state that can't be stored on the instance
+     */
+    private handleAsrReconnection;
+    /**
+     * Private method to handle STV reconnection logic.
+     * Uses instance fields for state (stvReconnectAttempts, stvReconnectAborted, stvBaseUrl, stvAgentId).
+     * Note: does NOT call createStvSession unless the server session is gone (404).
+     *
+     * @param connectionId - Connection ID that failed
+     * @param error - Error that caused the failure
+     * @param state - Minimal reconnection state that can't be stored on the instance
+     */
+    private handleStvReconnection;
+    /**
+     * Test method to manually trigger reconnection by emitting connection failed event
+     * Used for testing reconnection logic in development/testing
+     *
+     * @param connectionType - Which connection to trigger reconnection for ('asr' or 'stv')
+     */
+    testCloseConnection(connectionType: 'asr' | 'stv'): void;
+    /**
+     * Register debug helpers on window for development/testing.
+     * Call this after initializing the session.
+     *
+     * window.killAllPeerConnections() — triggers PC_CONNECTION_FAILED on all active connections,
+     * causing the reconnection logic to fire (same as a real network failure).
+     */
+    registerDebugGlobals(): void;
+    /**
+     * Subscribe to speaking state changes
+     * Core SDK will START emitting events when first listener is added
+     * @param callback - Called when user starts/stops speaking
+     * @returns Unsubscribe function
+     */
+    onSpeakingStateChanged(callback: (speaking: boolean) => void): () => void;
+    /**
+     * Subscribe to raw volume levels (for high-precision features)
+     * Core SDK will START emitting volume events when first listener is added
+     * @param callback - Called every 50ms with current volume
+     * @returns Unsubscribe function
+     */
+    onAudioVolumeLevel(callback: (volume: number) => void): () => void;
+    /**
+     * Update speaking threshold dynamically
+     * @param threshold - New volume threshold (default: 300)
+     */
+    setSpeakingThreshold(threshold: number): void;
+    /**
+     * Get current speaking state (cached from last event)
+     * @returns true if currently speaking, false otherwise
+     */
+    isSpeaking(): boolean;
+    /**
+     * Check if user is speaking while muted
+     * Useful for showing "unmute" prompts
+     * @returns true if speaking while audio is muted
+     */
+    isSpeakingWhileMuted(): boolean;
+    /**
+     * Destroy the session and clean up all resources
+     * Closes all connections and removes all DOM elements
+     */
+    destroy(): void;
+    /**
+     * Mutes audio
+     * Routes through connection to maintain state consistency
+     */
+    muteASRAudio(): Promise<boolean>;
+    /**
+     * Unmutes audio
+     * Routes through connection to maintain state consistency
+     */
+    unmuteASRAudio(): Promise<boolean>;
+    /**
+     * Gets audio mute state for ASR connection
+     * Returns actual connection state when connected, otherwise checks core session
+     */
+    getASRAudioState(): MediaTrackState | null;
+    /**
+     * Mutes video
+     * Routes through connection to maintain state consistency
+     */
+    muteASRVideo(): Promise<void>;
+    /**
+     * Unmutes video
+     * Routes through connection to maintain state consistency
+     */
+    unmuteASRVideo(): Promise<boolean>;
+    /**
+     * Reattaches the current video track to the mapped video element after unmute.
+     * The peer connection sender is updated by the core unmute flow,
+     * but the local preview element needs its srcObject refreshed.
+     */
+    private reattachVideoToElement;
+    /**
+     * Gets video mute state for ASR connection
+     * Returns actual connection state when connected, otherwise checks core session
+     */
+    getASRVideoState(): MediaTrackState | null;
+    /**
+     * Enable noise reduction
+     * @param mode - NR mode to use (default: Mode11)
+     * @returns Promise<boolean> - True if successful, false otherwise
+     */
+    enableNoiseReduction(mode?: AudioNrMode): Promise<boolean>;
+    /**
+     * Disable noise reduction
+     * Falls back to raw audio track
+     */
+    disableNoiseReduction(): Promise<boolean>;
+    /**
+     * Switch noise reduction mode
+     * @param mode - New NR mode
+     * @returns Promise<boolean> - True if successful, false otherwise
+     */
+    setNoiseReductionMode(mode: AudioNrMode): Promise<boolean>;
+    /**
+     * Get current noise reduction state
+     * @returns Object with enabled status and current mode
+     */
+    getNoiseReductionState(): {
+        enabled: boolean;
+        mode: AudioNrMode;
+    };
+    /**
+     * DEBUG: Start audio loopback for testing
+     * Creates an audio element that plays back the published audio track
+     * Useful for testing noise reduction and audio processing
+     * @returns The created audio element or existing one
+     */
+    dbgStartAudioLoopback(): boolean;
+    /**
+     * DEBUG: Stop audio loopback
+     * Removes the audio element and stops playback
+     */
+    dbgStopAudioLoopback(): void;
+}

package/src/lib/session/index.d.ts

@@ -0,0 +1 @@
+export * from './EselfSession';

package/src/lib/signaling/EselfSignaling.d.ts

@@ -0,0 +1,76 @@
+import { SignalingOptions } from './types';
+import { IceCandidateData } from '../session';
+/**
+ * EselfSignaling: Flexible signaling client supporting HTTP and WebSocket modes
+ *
+ * Two modes of operation:
+ * 1. HTTP Mode: SDK manages fetch() calls to provided endpoints
+ * 2. WebSocket Mode: App provides callbacks that manage WebSocket communication
+ *
+ * Priority: If a callback is provided, it's used. Otherwise, falls back to HTTP.
+ *
+ * Example HTTP usage:
+ *   signalingClient.updateOptions({
+ *     asrEndpoint: 'https://api.example.com/asr/signaling',
+ *     stvEndpoint: 'https://api.example.com/stv/signaling'
+ *   });
+ *
+ * Example WebSocket usage:
+ *   signalingClient.updateOptions({
+ *     sendOfferCallback: async (connId, sdp) => {
+ *       ws.send(JSON.stringify({ type: 'offer', connectionId: connId, sdp }));
+ *       return await waitForAnswer();
+ *     },
+ *     sendAnswerCallback: async (connId, sdp) => {
+ *       ws.send(JSON.stringify({ type: 'answer', connectionId: connId, sdp }));
+ *     }
+ *   });
+ */
+export declare class EselfSignaling {
+    private logger;
+    private options;
+    constructor(initialOptions?: SignalingOptions);
+    /**
+     * Update signaling options at runtime
+     * Allows switching between HTTP and WebSocket modes dynamically
+     *
+     * @param options - New signaling options to merge with existing
+     */
+    updateOptions(options: SignalingOptions): void;
+    /**
+     * Send an offer and wait for an answer
+     * Priority: Uses sendOfferCallback if provided, otherwise HTTP endpoint
+     *
+     * @param connectionId - Connection ID ('asr' or 'stv')
+     * @param sdp - Local SDP offer
+     * @param isReconnect - Flag indicating if this is a reconnection attempt
+     * @returns Remote SDP answer
+     * @throws SignalingError if signaling fails
+     */
+    sendOffer(connectionId: string, sdp: RTCSessionDescriptionInit, isReconnect?: boolean): Promise<RTCSessionDescriptionInit>;
+    /**
+     * Send an answer to a received offer
+     * Priority: Uses sendAnswerCallback if provided, otherwise HTTP endpoint
+     *
+     * @param connectionId - Connection ID ('asr' or 'stv')
+     * @param sdp - Local SDP answer
+     * @throws SignalingError if signaling fails
+     */
+    sendAnswer(connectionId: string, sdp: RTCSessionDescriptionInit): Promise<void>;
+    /**
+     * Send an ICE candidate
+     * Priority: Uses sendICECandidateCallback if provided, otherwise HTTP endpoint
+     *
+     * @param connectionId - Connection ID ('asr' or 'stv')
+     * @param candidate - ICE candidate
+     * @throws SignalingError if signaling fails
+     */
+    sendICECandidate(connectionId: string, candidate: IceCandidateData): Promise<void>;
+    /**
+     * Get the HTTP endpoint for a specific connection
+     * @param connectionId - Connection ID ('asr' or 'stv')
+     * @returns Endpoint URL or undefined if not configured
+     */
+    private getEndpointForConnection;
+}
+export default EselfSignaling;

package/src/lib/signaling/KasSignalingAdapter.d.ts

@@ -0,0 +1,55 @@
+/**
+ * KasSignalingAdapter: Adapter for kas backend signaling protocol
+ *
+ * Adapts the kas backend's specific HTTP API format:
+ * - POST /offer -> returns { sdp, type, session_id }
+ * - POST /start -> starts the session
+ *
+ * This adapter creates callbacks that can be used with EselfSignaling
+ */
+export declare class KasSignalingAdapter {
+    private logger;
+    private asrBaseUrl;
+    private stvBaseUrl;
+    private sessionIds;
+    /**
+     * @param asrBaseUrl - Base URL for ASR service (e.g., 'http://localhost:8081')
+     * @param stvBaseUrl - Base URL for STV service (e.g., 'http://localhost:8080')
+     */
+    constructor(asrBaseUrl: string, stvBaseUrl: string);
+    /**
+     * Get the base URL for a specific connection
+     */
+    private getBaseUrl;
+    /**
+     * Create sendOffer callback for use with EselfSignaling
+     * Handles the kas backend's offer/answer protocol
+     */
+    createSendOfferCallback(): (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<RTCSessionDescriptionInit>;
+    /**
+     * Start the session by calling the /start endpoint
+     * This should be called after the peer connection is established
+     *
+     * @param connectionId - Connection ID ('asr' or 'stv')
+     */
+    startSession(connectionId: string): Promise<void>;
+    /**
+     * Create sendAnswer callback for use with EselfSignaling
+     * (Not typically used with kas backend since we're the client)
+     */
+    createSendAnswerCallback(): (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<void>;
+    /**
+     * Create sendICECandidate callback for use with EselfSignaling
+     * (Not used with kas backend - ICE candidates are bundled in SDP)
+     */
+    createSendICECandidateCallback(): (connectionId: string, candidate: RTCIceCandidate) => Promise<void>;
+    /**
+     * Get the session ID for a connection (if available)
+     */
+    getSessionId(connectionId: string): string | undefined;
+    /**
+     * Clear session data
+     */
+    clear(): void;
+}
+export default KasSignalingAdapter;

package/src/lib/signaling/SrsSignalingAdapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * SrsSignalingAdapter: Adapter for SRS (Simple Realtime Server) WHEP protocol
+ *
+ * Adapts the SRS WHEP (WebRTC-HTTP Egress Protocol) format:
+ * - POST /rtc/v1/whep/?app={app}&stream={stream} with plain SDP text
+ * - Response: Plain SDP text (not JSON)
+ * - Content-Type: application/sdp (not application/json)
+ * - No session management endpoints
+ *
+ * This adapter creates callbacks that can be used with EselfSignaling
+ */
+export declare class SrsSignalingAdapter {
+    private logger;
+    private baseUrl;
+    private app;
+    /**
+     * @param baseUrl - Base URL for SRS server (e.g., 'http://localhost:1985')
+     * @param app - SRS app name (default: 'live')
+     */
+    constructor(baseUrl: string, app?: string);
+    /**
+     * Construct WHEP endpoint URL
+     * Format: {baseUrl}/rtc/v1/whep/?app={app}&stream={stream}
+     */
+    private constructWhepUrl;
+    /**
+     * Create sendOffer callback for use with EselfSignaling
+     * Handles the SRS WHEP protocol
+     */
+    createSendOfferCallback(): (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<RTCSessionDescriptionInit>;
+    /**
+     * Create sendAnswer callback for use with EselfSignaling
+     * (Not used with WHEP protocol - client always sends offer)
+     */
+    createSendAnswerCallback(): (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<void>;
+    /**
+     * Create sendICECandidate callback for use with EselfSignaling
+     * (Not used with SRS - ICE candidates are bundled in SDP)
+     */
+    createSendICECandidateCallback(): (connectionId: string, candidate: RTCIceCandidate) => Promise<void>;
+    /**
+     * Get the configured app name
+     */
+    getAppName(): string;
+    /**
+     * Get the base URL
+     */
+    getBaseUrl(): string;
+}
+export default SrsSignalingAdapter;

package/src/lib/signaling/WhepSignalingAdapter.d.ts

@@ -0,0 +1,70 @@
+/**
+ * HTTP status codes used by the WHEP protocol.
+ */
+export declare enum WhepStatus {
+    OK = 200,
+    CREATED = 201,// Offer accepted, SDP answer returned
+    NO_ACTIVE_SESSION = 404,// session_id not in registry (no active session)
+    ALREADY_HAS_VIEWER = 409,// Session already has an active viewer (DELETE it first)
+    WRONG_CONTENT_TYPE = 415,// Wrong Content-Type (not application/sdp)
+    INTERNAL_SERVER_ERROR = 500
+}
+/**
+ * WhepSignalingAdapter: Adapter for standard WHEP (WebRTC-HTTP Egress Protocol)
+ *
+ * Handles the STV server's WHEP endpoint:
+ * - POST /whep/{sessionId} with plain SDP text → receives SDP answer + Location header
+ * - DELETE {Location} for session teardown
+ *
+ * The browser is the WHEP subscriber (viewer).
+ * The STV server is the WHIP publisher (ingestion side).
+ */
+export declare class WhepSignalingAdapter {
+    private logger;
+    private baseUrl;
+    private sessionLocations;
+    /**
+     * @param baseUrl - Base URL for STV server (e.g., 'http://localhost:8080')
+     */
+    constructor(baseUrl: string);
+    /**
+     * Update the base URL for the WHEP adapter
+     * Allows changing STV server dynamically between joinSTV calls
+     *
+     * @param newUrl - New STV base URL (e.g., 'http://localhost:8080')
+     * @note Existing session locations (stored Location headers) are NOT cleared.
+     *       If switching STV servers, ensure previous sessions are cleaned up first.
+     */
+    updateBaseUrl(newUrl: string): void;
+    /**
+     * Construct WHEP endpoint URL
+     * Format: {baseUrl}/whep/session/{sessionId}
+     */
+    private constructWhepUrl;
+    /**
+     * Create sendOffer callback for use with EselfSignaling.
+     * Handles the standard WHEP protocol:
+     * POST SDP offer → plain text SDP answer + stores Location header.
+     */
+    createSendOfferCallback(): (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<RTCSessionDescriptionInit>;
+    /**
+     * Create sendAnswer callback — no-op for WHEP (client always sends offer).
+     */
+    createSendAnswerCallback(): (_connectionId: string, _sdp: RTCSessionDescriptionInit) => Promise<void>;
+    /**
+     * Create sendICECandidate callback — no-op for WHEP (ICE bundled in SDP).
+     */
+    createSendICECandidateCallback(): (connectionId: string, _candidate: RTCIceCandidate) => Promise<void>;
+    /**
+     * Teardown the WHEP session by sending DELETE to the Location URL.
+     * Call this when closing the viewer connection.
+     *
+     * @param connectionId - The connection ID used in joinSTV / sendOffer
+     */
+    disconnect(connectionId: string): Promise<void>;
+    /**
+     * Get the base URL.
+     */
+    getBaseUrl(): string;
+}
+export default WhepSignalingAdapter;

package/src/lib/signaling/index.d.ts

@@ -0,0 +1,5 @@
+export { EselfSignaling, default as EselfSignalingDefault, } from './EselfSignaling';
+export { KasSignalingAdapter } from './KasSignalingAdapter';
+export { SrsSignalingAdapter } from './SrsSignalingAdapter';
+export { WhepSignalingAdapter } from './WhepSignalingAdapter';
+export * from './types';

package/src/lib/signaling/types.d.ts

@@ -0,0 +1,34 @@
+import { IceCandidateData } from '../session';
+/**
+ * Signaling options for EselfSignaling
+ *
+ * Supports two modes:
+ * 1. HTTP Mode: Provide endpoint URLs, SDK will use fetch() for signaling
+ * 2. WebSocket Mode: Provide callback functions, app manages the WebSocket connection
+ *
+ * Can be mixed (e.g., HTTP for ASR, callbacks for STV)
+ */
+export type SignalingOptions = {
+    asrEndpoint?: string;
+    stvEndpoint?: string;
+    sendOfferCallback?: (connectionId: string, sdp: RTCSessionDescriptionInit, isReconnect: boolean) => Promise<RTCSessionDescriptionInit>;
+    sendAnswerCallback?: (connectionId: string, sdp: RTCSessionDescriptionInit) => Promise<void>;
+    sendICECandidateCallback?: (connectionId: string, candidate: IceCandidateData) => Promise<void>;
+};
+/**
+ * Signaling message types
+ */
+export declare enum SignalingMessageType {
+    OFFER = "offer",
+    ANSWER = "answer",
+    ICE_CANDIDATE = "iceCandidate"
+}
+/**
+ * Signaling error types
+ */
+export declare class SignalingError extends Error {
+    readonly connectionId: string;
+    readonly messageType: SignalingMessageType;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, connectionId: string, messageType: SignalingMessageType, statusCode?: number | undefined);
+}