ulai-js-sdk 0.0.0-stage → 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import { ConnectOptions, JoinRoomOptions } from './types';
+import { Room } from './room';
+export declare class UlaiClient {
+    private url;
+    private apiKey?;
+    constructor(options: ConnectOptions);
+    /**
+     * Joins a room by making an API request to the control plane,
+     * then connects WebRTC and Event subscriptions.
+     */
+    joinRoom(options: JoinRoomOptions): Promise<Room>;
+}

package/dist/client.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UlaiClient = void 0;
+const room_1 = require("./room");
+class UlaiClient {
+    url;
+    apiKey;
+    constructor(options) {
+        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.
+     */
+    async joinRoom(options) {
+        const headers = {
+            '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_1.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;
+    }
+}
+exports.UlaiClient = UlaiClient;

package/dist/events.d.ts

@@ -0,0 +1,8 @@
+import EventEmitter from 'eventemitter3';
+export declare class EventsClient extends EventEmitter {
+    private ws;
+    private url;
+    constructor(cpBase: string);
+    connect(sessionId: string, eventsToken: string): void;
+    close(): void;
+}

package/dist/events.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsClient = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+class EventsClient extends eventemitter3_1.default {
+    ws = null;
+    url;
+    constructor(cpBase) {
+        super();
+        const scheme = cpBase.startsWith('https') ? 'wss' : 'ws';
+        const host = cpBase.replace(/^https?:\/\//, '').replace(/\/$/, '');
+        this.url = `${scheme}://${host}/api/v1/events`;
+    }
+    connect(sessionId, eventsToken) {
+        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);
+        };
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+exports.EventsClient = EventsClient;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./room"), exports);
+__exportStar(require("./signaling"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./types"), exports);

package/dist/room.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from 'eventemitter3';
+import { RoomEvent, JoinRoomOptions } from './types';
+export declare class Room extends EventEmitter<RoomEvent> {
+    private cpBase;
+    private signaling;
+    private eventsClient;
+    private peerConnection;
+    private localStream;
+    private remoteStreams;
+    roomId: string | null;
+    participantId: string | null;
+    constructor(cpBase: string);
+    connect(options: JoinRoomOptions): Promise<void>;
+    private setupEventsClient;
+    private setupSignaling;
+    publishAudio(): Promise<void>;
+    disconnect(): void;
+}

package/dist/room.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+const signaling_1 = require("./signaling");
+const events_1 = require("./events");
+class Room extends eventemitter3_1.default {
+    cpBase;
+    signaling = null;
+    eventsClient = null;
+    peerConnection = null;
+    localStream = null;
+    remoteStreams = new Map();
+    roomId = null;
+    participantId = null;
+    constructor(cpBase) {
+        super();
+        this.cpBase = cpBase;
+    }
+    async connect(options) {
+        this.roomId = options.roomId;
+        this.participantId = options.participantId || '';
+        // 1. Setup Control Plane Events
+        if (options.eventsToken) {
+            this.eventsClient = new events_1.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 signaling_1.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();
+        }
+    }
+    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));
+    }
+    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') {
+                    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');
+        });
+    }
+    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);
+        }
+    }
+    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');
+    }
+}
+exports.Room = Room;

package/dist/signaling.d.ts

@@ -0,0 +1,10 @@
+import EventEmitter from 'eventemitter3';
+import { SignalMessage } from './types';
+export declare class SignalingClient extends EventEmitter {
+    private ws;
+    private url;
+    constructor(nodeAddress: string, ticket: string);
+    connect(): void;
+    send(message: SignalMessage): void;
+    close(): void;
+}

package/dist/signaling.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalingClient = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+class SignalingClient extends eventemitter3_1.default {
+    ws = null;
+    url;
+    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}`;
+    }
+    connect() {
+        this.ws = new WebSocket(this.url);
+        this.ws.onopen = () => {
+            this.emit('connected');
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const msg = 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);
+        };
+    }
+    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);
+        }
+    }
+    close() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+exports.SignalingClient = SignalingClient;

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+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/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "ulai-js-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "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"
+  },
+  "keywords": [
+    "ulai",
+    "webrtc",
+    "agent",
+    "sdk"
+  ],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "eventemitter3": "^5.0.1"
+  }
+}

package/src/client.ts

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,64 @@
+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

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

package/src/room.ts

@@ -0,0 +1,163 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,15 @@
+{
+  "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/**/*"]
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.