ulai-js-sdk 0.1.0 → 0.1.2

package/dist/signaling.js

@@ -8,45 +8,160 @@ const eventemitter3_1 = __importDefault(require("eventemitter3"));
 class SignalingClient extends eventemitter3_1.default {
     ws = null;
     url;
+    outbox = [];
+    isClosedManually = false;
+    retryAttempts = 0;
+    maxRetries = 5;
+    reconnectTimer = null;
+    heartbeatTimer = null;
     constructor(nodeAddress, ticket) {
         super();
-        const scheme = nodeAddress.startsWith('localhost') || nodeAddress.startsWith('127.0.0.1') ? 'ws' : 'wss';
-        this.url = `${scheme}://${nodeAddress}/webrtc/room?ticket=${ticket}`;
+        this.url = this.buildUrl(nodeAddress, ticket);
+    }
+    buildUrl(nodeAddress, ticket) {
+        const cleanAddress = nodeAddress
+            .replace(/^https?:\/\//, '')
+            .replace(/^wss?:\/\//, '')
+            .replace(/\/$/, '');
+        const isLocal = cleanAddress.startsWith('localhost') ||
+            cleanAddress.startsWith('127.0.0.1');
+        // Default to wss unless connecting to localhost/127.0.0.1 over plain http
+        let scheme = 'wss';
+        if (isLocal) {
+            scheme = 'ws';
+        }
+        else if (typeof window !== 'undefined' && window.location.protocol === 'http:') {
+            scheme = 'ws';
+        }
+        return `${scheme}://${cleanAddress}/webrtc/room?ticket=${encodeURIComponent(ticket)}`;
     }
     connect() {
-        this.ws = new WebSocket(this.url);
-        this.ws.onopen = () => {
-            this.emit('connected');
-        };
-        this.ws.onmessage = (event) => {
+        this.isClosedManually = false;
+        this.cleanupSocket();
+        try {
+            this.ws = new WebSocket(this.url);
+            this.ws.onopen = () => {
+                const wasReconnecting = this.retryAttempts > 0;
+                this.retryAttempts = 0;
+                this.flushOutbox();
+                this.startHeartbeat();
+                if (wasReconnecting) {
+                    this.emit('reconnected');
+                }
+                else {
+                    this.emit('connected');
+                }
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const msg = JSON.parse(event.data);
+                    this.emit('message', msg);
+                }
+                catch (err) {
+                    console.error('[Signaling] Failed to parse message', err);
+                }
+            };
+            this.ws.onclose = (event) => {
+                this.stopHeartbeat();
+                if (this.isClosedManually) {
+                    this.emit('disconnected');
+                    return;
+                }
+                if (this.retryAttempts < this.maxRetries) {
+                    this.retryAttempts++;
+                    const delay = Math.min(1000 * Math.pow(1.5, this.retryAttempts), 10000);
+                    console.warn(`[Signaling] Connection dropped. Retrying in ${Math.round(delay)}ms (attempt ${this.retryAttempts}/${this.maxRetries})...`);
+                    this.emit('reconnecting', { attempt: this.retryAttempts });
+                    this.reconnectTimer = setTimeout(() => {
+                        if (!this.isClosedManually) {
+                            this.connect();
+                        }
+                    }, delay);
+                }
+                else {
+                    console.error('[Signaling] Max reconnect attempts exceeded');
+                    this.emit('disconnected', event);
+                }
+            };
+            this.ws.onerror = (error) => {
+                this.emit('error', error);
+            };
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    send(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
             try {
-                const msg = JSON.parse(event.data);
-                this.emit('message', msg);
+                this.ws.send(JSON.stringify(message));
             }
             catch (err) {
-                console.error('Failed to parse signaling message', err);
+                console.error('[Signaling] Failed to send message, buffering in outbox', err);
+                this.outbox.push(message);
             }
-        };
-        this.ws.onclose = () => {
-            this.emit('disconnected');
-        };
-        this.ws.onerror = (error) => {
-            this.emit('error', error);
-        };
-    }
-    send(message) {
-        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify(message));
         }
         else {
-            console.warn('Cannot send message, WebSocket is not open', message);
+            // Buffer in outbox until WebSocket connects
+            this.outbox.push(message);
         }
     }
-    close() {
+    flushOutbox() {
+        while (this.outbox.length > 0 && this.ws && this.ws.readyState === WebSocket.OPEN) {
+            const msg = this.outbox.shift();
+            if (msg) {
+                try {
+                    this.ws.send(JSON.stringify(msg));
+                }
+                catch (err) {
+                    console.error('[Signaling] Error flushing outbox message', err);
+                    this.outbox.unshift(msg);
+                    break;
+                }
+            }
+        }
+    }
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                // Send lightweight keepalive if socket is open
+                try {
+                    this.ws.send(JSON.stringify({ type: 'ping' }));
+                }
+                catch (_) { }
+            }
+        }, 20000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    cleanupSocket() {
+        this.stopHeartbeat();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         if (this.ws) {
-            this.ws.close();
+            this.ws.onopen = null;
+            this.ws.onmessage = null;
+            this.ws.onclose = null;
+            this.ws.onerror = null;
+            try {
+                this.ws.close();
+            }
+            catch (_) { }
             this.ws = null;
         }
     }
+    close() {
+        this.isClosedManually = true;
+        this.outbox = [];
+        this.cleanupSocket();
+        this.emit('disconnected');
+    }
 }
 exports.SignalingClient = SignalingClient;

package/dist/types.d.ts

@@ -9,13 +9,15 @@ export interface JoinRoomOptions {
     eventsToken?: string;
     ticket?: string;
     nodeAddress?: string;
+    iceServers?: RTCIceServer[];
+    autoSubscribeAudio?: boolean;
 }
-export type RoomEvent = 'connected' | 'disconnected' | 'reconnecting' | 'trackSubscribed' | 'trackUnsubscribed' | 'participantJoined' | 'participantLeft' | 'roster' | 'transcriptDelta' | 'sessionTerminated' | 'error';
+export type RoomEvent = 'connected' | 'disconnected' | 'reconnecting' | 'reconnected' | 'trackSubscribed' | 'trackUnsubscribed' | 'participantJoined' | 'participantLeft' | 'roster' | 'transcriptDelta' | 'sessionTerminated' | 'muteChanged' | 'error';
 export interface SignalMessage {
-    type: 'offer' | 'answer' | 'ice-candidate' | 'candidate' | 'join' | 'leave';
+    type: 'offer' | 'answer' | 'ice-candidate' | 'candidate' | 'restart-offer' | 'join' | 'leave' | 'ping';
     payload?: any;
-    sdp?: any;
-    candidate?: any;
+    sdp?: string;
+    candidate?: string;
 }
 export interface TranscriptDelta {
     segment_id: string;

package/package.json

@@ -1,20 +1,30 @@
 {
   "name": "ulai-js-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Ulai Cloud JS/TS Client SDK for WebRTC Sessions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "dev": "tsc -w"
+    "dev": "tsc -w",
+    "prepublishOnly": "npm run build"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "keywords": [
     "ulai",
     "webrtc",
-    "agent",
+    "ai-agent",
+    "voice-agent",
+    "speech",
+    "sfu",
+    "realtime",
+    "audio",
     "sdk"
   ],
-  "author": "",
+  "author": "Ulai Team",
   "license": "MIT",
   "devDependencies": {
     "typescript": "^5.0.0"

package/src/client.ts

@@ -1,59 +0,0 @@
-import { ConnectOptions, JoinRoomOptions } from './types';
-import { Room } from './room';
-
-export class UlaiClient {
-  private url: string;
-  private apiKey?: string;
-
-  constructor(options: ConnectOptions) {
-    this.url = options.url.replace(/\/$/, '');
-    this.apiKey = options.apiKey;
-  }
-
-  /**
-   * Joins a room by making an API request to the control plane,
-   * then connects WebRTC and Event subscriptions.
-   */
-  public async joinRoom(options: JoinRoomOptions): Promise<Room> {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-    };
-
-    if (this.apiKey) {
-      headers['Authorization'] = `Bearer ${this.apiKey}`;
-    }
-
-    const body = {
-      kind: 'STANDARD',
-      can_publish: true,
-      can_subscribe: true,
-      participant_id: options.participantId,
-    };
-
-    const res = await fetch(`${this.url}/api/v1/sessions/${options.roomId}/join`, {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(body),
-    });
-
-    if (!res.ok) {
-      const errText = await res.text();
-      throw new Error(`Failed to join room: ${res.status} ${errText}`);
-    }
-
-    const joinData = await res.json();
-    
-    // joinData typically contains: session_id, events_token, connection_id, ticket, node: { address }
-    const room = new Room(this.url);
-    
-    await room.connect({
-      roomId: joinData.session_id || options.roomId,
-      participantId: joinData.connection_id || options.participantId,
-      eventsToken: joinData.events_token,
-      ticket: joinData.ticket,
-      nodeAddress: joinData.node?.address
-    });
-
-    return room;
-  }
-}

package/src/events.ts

@@ -1,64 +0,0 @@
-import EventEmitter from 'eventemitter3';
-
-export class EventsClient extends EventEmitter {
-  private ws: WebSocket | null = null;
-  private url: string;
-
-  constructor(cpBase: string) {
-    super();
-    const scheme = cpBase.startsWith('https') ? 'wss' : 'ws';
-    const host = cpBase.replace(/^https?:\/\//, '').replace(/\/$/, '');
-    this.url = `${scheme}://${host}/api/v1/events`;
-  }
-
-  public connect(sessionId: string, eventsToken: string) {
-    this.ws = new WebSocket(this.url);
-
-    this.ws.onopen = () => {
-      this.ws?.send(JSON.stringify({ 
-        action: 'subscribe', 
-        scope: 'session', 
-        session_id: sessionId, 
-        token: eventsToken 
-      }));
-    };
-
-    this.ws.onmessage = (event) => {
-      try {
-        const msg = JSON.parse(event.data);
-        if (msg.type === 'subscribed') {
-          this.emit('connected', msg);
-        } else if (msg.type === 'transcript_delta') {
-          this.emit('transcript_delta', msg);
-        } else if (msg.type === 'roster') {
-          this.emit('roster', msg);
-        } else if (msg.type === 'session_terminated') {
-          this.emit('session_terminated', msg);
-        } else if (msg.type === 'participant_joined') {
-          this.emit('participant_joined', msg);
-        } else if (msg.type === 'participant_left') {
-          this.emit('participant_left', msg);
-        } else if (msg.type === 'error') {
-          this.emit('error', msg);
-        }
-      } catch (err) {
-        console.error('Failed to parse events message', err);
-      }
-    };
-
-    this.ws.onclose = () => {
-      this.emit('disconnected');
-    };
-
-    this.ws.onerror = (error) => {
-      this.emit('error', error);
-    };
-  }
-
-  public close() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from './client';
-export * from './room';
-export * from './signaling';
-export * from './events';
-export * from './types';

package/src/room.ts

@@ -1,163 +0,0 @@
-import EventEmitter from 'eventemitter3';
-import { SignalingClient } from './signaling';
-import { EventsClient } from './events';
-import { RoomEvent, JoinRoomOptions } from './types';
-
-export class Room extends EventEmitter<RoomEvent> {
-  private cpBase: string;
-  private signaling: SignalingClient | null = null;
-  private eventsClient: EventsClient | null = null;
-  
-  private peerConnection: RTCPeerConnection | null = null;
-  private localStream: MediaStream | null = null;
-  private remoteStreams: Map<string, MediaStream> = new Map();
-
-  public roomId: string | null = null;
-  public participantId: string | null = null;
-
-  constructor(cpBase: string) {
-    super();
-    this.cpBase = cpBase;
-  }
-
-  public async connect(options: JoinRoomOptions) {
-    this.roomId = options.roomId;
-    this.participantId = options.participantId || '';
-
-    // 1. Setup Control Plane Events
-    if (options.eventsToken) {
-      this.eventsClient = new EventsClient(this.cpBase);
-      this.setupEventsClient();
-      this.eventsClient.connect(this.roomId, options.eventsToken);
-    }
-
-    // 2. Setup WebRTC Signaling if nodeAddress and ticket are provided
-    if (options.nodeAddress && options.ticket) {
-      this.signaling = new SignalingClient(options.nodeAddress, options.ticket);
-      this.setupSignaling();
-
-      this.peerConnection = new RTCPeerConnection({
-        iceServers: [
-          { urls: 'stun:stun.l.google.com:19302' },
-          { urls: ['turn:turn.ulai.in:3478', 'turns:turn.ulai.in:5349'], username: 'ulai', credential: 'xulaizrt' }
-        ]
-      });
-
-      this.peerConnection.onicecandidate = (event) => {
-        if (event.candidate && this.signaling) {
-          this.signaling.send({ type: 'candidate', candidate: JSON.stringify(event.candidate.toJSON()) });
-        }
-      };
-
-      this.peerConnection.ontrack = (event) => {
-        const stream = event.streams[0];
-        if (stream) {
-          this.remoteStreams.set(stream.id, stream);
-          this.emit('trackSubscribed', event.track, stream);
-        }
-      };
-
-      this.peerConnection.onconnectionstatechange = () => {
-        switch (this.peerConnection?.connectionState) {
-          case 'connected':
-            this.emit('connected');
-            break;
-          case 'disconnected':
-          case 'failed':
-            this.emit('disconnected');
-            break;
-        }
-      };
-
-      this.signaling.connect();
-    }
-  }
-
-  private setupEventsClient() {
-    if (!this.eventsClient) return;
-
-    this.eventsClient.on('roster', (msg) => this.emit('roster', msg));
-    this.eventsClient.on('participant_joined', (msg) => this.emit('participantJoined', msg));
-    this.eventsClient.on('participant_left', (msg) => this.emit('participantLeft', msg));
-    this.eventsClient.on('transcript_delta', (msg) => this.emit('transcriptDelta', msg));
-    this.eventsClient.on('session_terminated', (msg) => {
-      this.emit('sessionTerminated', msg);
-      this.disconnect();
-    });
-    this.eventsClient.on('error', (err) => this.emit('error', err));
-  }
-
-  private setupSignaling() {
-    if (!this.signaling) return;
-
-    this.signaling.on('connected', async () => {
-      // Create initial offer when signaling connects
-      if (this.peerConnection) {
-        const offer = await this.peerConnection.createOffer();
-        await this.peerConnection.setLocalDescription(offer);
-        this.signaling!.send({ type: 'offer', sdp: this.peerConnection.localDescription?.sdp });
-      }
-    });
-
-    this.signaling.on('message', async (msg) => {
-      if (!this.peerConnection) return;
-
-      try {
-        if (msg.type === 'offer' || msg.type === 'restart-offer' as any) {
-          await this.peerConnection.setRemoteDescription(new RTCSessionDescription({ type: 'offer', sdp: msg.sdp }));
-          const answer = await this.peerConnection.createAnswer();
-          await this.peerConnection.setLocalDescription(answer);
-          this.signaling!.send({ type: 'answer', sdp: this.peerConnection.localDescription?.sdp });
-        } else if (msg.type === 'answer') {
-          await this.peerConnection.setRemoteDescription(new RTCSessionDescription({ type: 'answer', sdp: msg.sdp }));
-        } else if (msg.type === 'candidate' && msg.candidate) {
-          await this.peerConnection.addIceCandidate(JSON.parse(msg.candidate));
-        }
-      } catch (err) {
-        console.error('Error handling signaling message', err);
-      }
-    });
-
-    this.signaling.on('disconnected', () => {
-      this.emit('disconnected');
-    });
-  }
-
-  public async publishAudio() {
-    try {
-      this.localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      if (this.peerConnection && this.localStream) {
-        this.localStream.getTracks().forEach((track) => {
-          this.peerConnection!.addTrack(track, this.localStream!);
-        });
-
-        // Renegotiate
-        const offer = await this.peerConnection.createOffer();
-        await this.peerConnection.setLocalDescription(offer);
-        this.signaling?.send({ type: 'offer', sdp: this.peerConnection.localDescription?.sdp });
-      }
-    } catch (err) {
-      console.error('Failed to publish audio:', err);
-      this.emit('error', err);
-    }
-  }
-
-  public disconnect() {
-    if (this.localStream) {
-      this.localStream.getTracks().forEach(track => track.stop());
-    }
-    if (this.peerConnection) {
-      this.peerConnection.close();
-      this.peerConnection = null;
-    }
-    if (this.signaling) {
-      this.signaling.close();
-      this.signaling = null;
-    }
-    if (this.eventsClient) {
-      this.eventsClient.close();
-      this.eventsClient = null;
-    }
-    this.emit('disconnected');
-  }
-}

package/src/signaling.ts

@@ -1,53 +0,0 @@
-import EventEmitter from 'eventemitter3';
-import { SignalMessage } from './types';
-
-export class SignalingClient extends EventEmitter {
-  private ws: WebSocket | null = null;
-  private url: string;
-
-  constructor(nodeAddress: string, ticket: string) {
-    super();
-    const scheme = nodeAddress.startsWith('localhost') || nodeAddress.startsWith('127.0.0.1') ? 'ws' : 'wss';
-    this.url = `${scheme}://${nodeAddress}/webrtc/room?ticket=${ticket}`;
-  }
-
-  public connect() {
-    this.ws = new WebSocket(this.url);
-
-    this.ws.onopen = () => {
-      this.emit('connected');
-    };
-
-    this.ws.onmessage = (event) => {
-      try {
-        const msg: SignalMessage = JSON.parse(event.data);
-        this.emit('message', msg);
-      } catch (err) {
-        console.error('Failed to parse signaling message', err);
-      }
-    };
-
-    this.ws.onclose = () => {
-      this.emit('disconnected');
-    };
-
-    this.ws.onerror = (error) => {
-      this.emit('error', error);
-    };
-  }
-
-  public send(message: SignalMessage) {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(message));
-    } else {
-      console.warn('Cannot send message, WebSocket is not open', message);
-    }
-  }
-
-  public close() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-}

package/src/types.ts

@@ -1,44 +0,0 @@
-export interface ConnectOptions {
-  url: string;
-  apiKey?: string;
-  token?: string;
-}
-
-export interface JoinRoomOptions {
-  roomId: string;
-  participantId?: string;
-  eventsToken?: string;
-  ticket?: string;
-  nodeAddress?: string;
-}
-
-export type RoomEvent = 
-  | 'connected'
-  | 'disconnected'
-  | 'reconnecting'
-  | 'trackSubscribed'
-  | 'trackUnsubscribed'
-  | 'participantJoined'
-  | 'participantLeft'
-  | 'roster'
-  | 'transcriptDelta'
-  | 'sessionTerminated'
-  | 'error';
-
-export interface SignalMessage {
-  type: 'offer' | 'answer' | 'ice-candidate' | 'candidate' | 'join' | 'leave';
-  payload?: any;
-  sdp?: any;
-  candidate?: any;
-}
-
-export interface TranscriptDelta {
-  segment_id: string;
-  speaker: 'user' | 'agent' | string;
-  text: string;
-  is_final: boolean;
-}
-
-export interface RosterMessage {
-  participants: any[];
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": ["DOM", "DOM.Iterable", "ES2022"]
-  },
-  "include": ["src/**/*"]
-}