@veroai/chat 0.1.0

package/dist/chunk-JI6KXOLF.js

@@ -0,0 +1,920 @@
+import EventEmitter from 'eventemitter3';
+
+// src/api/index.ts
+var ChatApi = class {
+  constructor(config) {
+    this.apiUrl = config.apiUrl.replace(/\/$/, "");
+    this.getToken = config.getToken;
+  }
+  async getHeaders() {
+    const token = await this.getToken();
+    return {
+      "Content-Type": "application/json",
+      ...token && { Authorization: `Bearer ${token}` }
+    };
+  }
+  async handleResponse(response) {
+    if (!response.ok) {
+      const errorText = await response.text();
+      let errorMessage;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.error?.message || errorJson.message || errorText;
+      } catch {
+        errorMessage = errorText;
+      }
+      throw new Error(errorMessage);
+    }
+    return response.json();
+  }
+  // ============================================================================
+  // Conversations
+  // ============================================================================
+  /**
+   * List all conversations for the current user
+   */
+  async listConversations() {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return data.conversations.map(transformConversation);
+  }
+  /**
+   * Get a specific conversation
+   */
+  async getConversation(conversationId) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return transformConversation(data.conversation);
+  }
+  /**
+   * Create a new conversation
+   */
+  async createConversation(params) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations`, {
+      method: "POST",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({
+        type: params.type || "direct",
+        name: params.name,
+        participant_ids: params.participantIds,
+        agent_config_id: params.agentConfigId,
+        metadata: params.metadata
+      })
+    });
+    const data = await this.handleResponse(response);
+    return transformConversation(data.conversation);
+  }
+  /**
+   * Mark conversation as read
+   */
+  async markConversationRead(conversationId) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}/read`, {
+      method: "POST",
+      headers: await this.getHeaders()
+    });
+    await this.handleResponse(response);
+  }
+  /**
+   * Leave a conversation
+   */
+  async leaveConversation(conversationId) {
+    const response = await fetch(
+      `${this.apiUrl}/v1/chat/conversations/${conversationId}/participants/me`,
+      {
+        method: "DELETE",
+        headers: await this.getHeaders()
+      }
+    );
+    await this.handleResponse(response);
+  }
+  // ============================================================================
+  // Messages
+  // ============================================================================
+  /**
+   * Get messages for a conversation
+   */
+  async getMessages(conversationId, params) {
+    const searchParams = new URLSearchParams();
+    if (params?.limit) searchParams.set("limit", String(params.limit));
+    if (params?.offset) searchParams.set("offset", String(params.offset));
+    if (params?.before) searchParams.set("before", params.before);
+    const url = `${this.apiUrl}/v1/chat/conversations/${conversationId}/messages?${searchParams}`;
+    const response = await fetch(url, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return {
+      messages: data.messages.map(transformMessage),
+      total: data.total,
+      hasMore: data.has_more,
+      limit: data.limit,
+      offset: data.offset
+    };
+  }
+  /**
+   * Send a message to a conversation
+   */
+  async sendMessage(conversationId, params) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}/messages`, {
+      method: "POST",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({
+        content: params.content,
+        message_type: params.messageType || "text",
+        metadata: params.metadata
+      })
+    });
+    const data = await this.handleResponse(response);
+    return transformMessage(data.message);
+  }
+  // ============================================================================
+  // Users
+  // ============================================================================
+  /**
+   * List all users (contacts)
+   */
+  async listUsers(options) {
+    const searchParams = new URLSearchParams();
+    if (options?.includeVirtual) searchParams.set("include_virtual", "true");
+    const url = `${this.apiUrl}/v1/chat/users?${searchParams}`;
+    const response = await fetch(url, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return data.users.map(transformUser);
+  }
+  /**
+   * Get online users
+   */
+  async getOnlineUsers() {
+    const response = await fetch(`${this.apiUrl}/v1/chat/users/online`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return data.users.map(transformUser);
+  }
+  /**
+   * Get current user profile
+   */
+  async getCurrentUser() {
+    const response = await fetch(`${this.apiUrl}/v1/chat/users/me`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return transformUser(data.user);
+  }
+  /**
+   * Get a specific user
+   */
+  async getUser(userId) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/users/${userId}`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return transformUser(data.user);
+  }
+  /**
+   * Update current user's presence status
+   */
+  async updateStatus(status, statusMessage) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/users/me/status`, {
+      method: "PUT",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({
+        status,
+        status_message: statusMessage
+      })
+    });
+    await this.handleResponse(response);
+  }
+  // ============================================================================
+  // Agents
+  // ============================================================================
+  /**
+   * Add agent to conversation
+   */
+  async addAgentToConversation(conversationId, agentConfigId, addAsParticipant = true) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}/agent`, {
+      method: "POST",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({
+        agent_config_id: agentConfigId,
+        add_as_participant: addAsParticipant
+      })
+    });
+    await this.handleResponse(response);
+  }
+  /**
+   * Remove agent from conversation
+   */
+  async removeAgentFromConversation(conversationId) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}/agent`, {
+      method: "DELETE",
+      headers: await this.getHeaders()
+    });
+    await this.handleResponse(response);
+  }
+  /**
+   * Toggle agent enabled/disabled
+   */
+  async toggleAgent(conversationId, enabled) {
+    const response = await fetch(`${this.apiUrl}/v1/chat/conversations/${conversationId}/agent`, {
+      method: "PATCH",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({ enabled })
+    });
+    await this.handleResponse(response);
+  }
+  /**
+   * List available agents
+   */
+  async listAgents() {
+    const response = await fetch(`${this.apiUrl}/v1/agent-configurations`, {
+      headers: await this.getHeaders()
+    });
+    const data = await this.handleResponse(response);
+    return data;
+  }
+  // ============================================================================
+  // Voice Rooms (LiveKit)
+  // ============================================================================
+  /**
+   * Create a new voice/video room
+   */
+  async createRoom(params) {
+    const response = await fetch(`${this.apiUrl}/v1/voice/rooms`, {
+      method: "POST",
+      headers: await this.getHeaders(),
+      body: JSON.stringify({
+        name: params.name,
+        empty_timeout: params.emptyTimeout,
+        max_participants: params.maxParticipants
+      })
+    });
+    const data = await this.handleResponse(response);
+    return transformRoomInfo(data.room);
+  }
+  /**
+   * Join an existing room and get access token
+   */
+  async joinRoom(params) {
+    const response = await fetch(
+      `${this.apiUrl}/v1/voice/rooms/${encodeURIComponent(params.roomName)}/join`,
+      {
+        method: "POST",
+        headers: await this.getHeaders(),
+        body: JSON.stringify({
+          participant_name: params.participantName,
+          can_publish: params.canPublish ?? true,
+          can_subscribe: params.canSubscribe ?? true
+        })
+      }
+    );
+    const data = await this.handleResponse(response);
+    return {
+      name: data.room_name,
+      wsUrl: data.ws_url,
+      token: data.token
+    };
+  }
+  /**
+   * Get room token for an existing room
+   * Convenience method for getting a token without creating
+   */
+  async getRoomToken(roomName, participantName) {
+    return this.joinRoom({ roomName, participantName });
+  }
+};
+function transformUser(raw) {
+  return {
+    id: raw.id,
+    email: raw.email,
+    firstName: raw.first_name,
+    lastName: raw.last_name,
+    isVirtual: raw.is_virtual,
+    agentConfigId: raw.agent_config_id,
+    status: raw.status,
+    statusMessage: raw.status_message,
+    lastSeen: raw.last_seen,
+    createdAt: raw.created_at
+  };
+}
+function transformParticipant(raw) {
+  return {
+    userId: raw.user_id,
+    role: raw.role,
+    isActive: raw.is_active,
+    joinedAt: raw.joined_at,
+    lastSeen: raw.last_seen,
+    user: raw.user ? transformUser(raw.user) : void 0
+  };
+}
+function transformConversation(raw) {
+  return {
+    id: raw.id,
+    name: raw.name,
+    type: raw.type,
+    isActive: raw.is_active,
+    lastMessageAt: raw.last_message_at,
+    agentEnabled: raw.agent_enabled,
+    agentConfigId: raw.agent_config_id,
+    participants: raw.participants?.map(transformParticipant),
+    unreadCount: raw.unread_count,
+    metadata: raw.metadata,
+    createdAt: raw.created_at,
+    updatedAt: raw.updated_at
+  };
+}
+function transformMessage(raw) {
+  return {
+    id: raw.id,
+    conversationId: raw.conversation_id,
+    content: raw.content,
+    messageType: raw.message_type,
+    senderId: raw.sender_id,
+    sender: raw.sender ? transformUser(raw.sender) : void 0,
+    readBy: raw.read_by?.map((r) => ({
+      userId: r.user_id,
+      readAt: r.read_at
+    })),
+    metadata: raw.metadata,
+    createdAt: raw.created_at,
+    editedAt: raw.edited_at
+  };
+}
+function transformRoomInfo(raw) {
+  return {
+    name: raw.name,
+    wsUrl: raw.ws_url,
+    token: raw.token
+  };
+}
+var WebSocketManager = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.ws = null;
+    this.state = "disconnected";
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.heartbeatTimer = null;
+    this.pendingMessages = [];
+    this.config = {
+      url: config.url,
+      getToken: config.getToken,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectInterval: config.reconnectInterval ?? 3e3,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      heartbeatInterval: config.heartbeatInterval ?? 3e4
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this.state === "connecting" || this.state === "connected") {
+      return;
+    }
+    this.state = "connecting";
+    const token = await this.config.getToken();
+    if (!token) {
+      this.state = "disconnected";
+      throw new Error("No authentication token available");
+    }
+    return new Promise((resolve, reject) => {
+      try {
+        const url = new URL(this.config.url);
+        url.searchParams.set("token", token);
+        this.ws = new WebSocket(url.toString());
+        this.ws.onopen = () => {
+          this.state = "connected";
+          this.reconnectAttempts = 0;
+          this.startHeartbeat();
+          this.flushPendingMessages();
+          this.emit("connected");
+          resolve();
+        };
+        this.ws.onclose = (event) => {
+          this.handleClose(event.reason);
+        };
+        this.ws.onerror = (event) => {
+          const error = new Error("WebSocket error");
+          this.emit("error", error);
+          if (this.state === "connecting") {
+            reject(error);
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.handleMessage(event.data);
+        };
+      } catch (error) {
+        this.state = "disconnected";
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.config.autoReconnect = false;
+    this.clearTimers();
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.state = "disconnected";
+  }
+  /**
+   * Send a message through the WebSocket
+   */
+  send(type, payload) {
+    const message = JSON.stringify({ type, payload, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+    if (this.isConnected()) {
+      this.ws.send(message);
+    } else {
+      this.pendingMessages.push(message);
+    }
+  }
+  /**
+   * Send typing indicator
+   */
+  sendTypingStart(conversationId) {
+    this.send("typing:start", { conversationId });
+  }
+  /**
+   * Stop typing indicator
+   */
+  sendTypingStop(conversationId) {
+    this.send("typing:stop", { conversationId });
+  }
+  /**
+   * Subscribe to a conversation for real-time updates
+   */
+  subscribeToConversation(conversationId) {
+    this.send("subscribe", { conversationId });
+  }
+  /**
+   * Unsubscribe from a conversation
+   */
+  unsubscribeFromConversation(conversationId) {
+    this.send("unsubscribe", { conversationId });
+  }
+  /**
+   * Update presence status
+   */
+  updatePresence(status, statusMessage) {
+    this.send("presence:update", { status, statusMessage });
+  }
+  /**
+   * Send call notification (ring, accept, reject, end)
+   * Note: Actual WebRTC signaling is handled by LiveKit
+   */
+  sendCallNotification(conversationId, action, callType, roomName) {
+    this.send("call", { conversationId, action, callType, roomName });
+  }
+  handleClose(reason) {
+    this.stopHeartbeat();
+    const wasConnected = this.state === "connected";
+    this.state = "disconnected";
+    this.ws = null;
+    if (wasConnected) {
+      this.emit("disconnected", reason);
+    }
+    if (this.config.autoReconnect && this.reconnectAttempts < this.config.maxReconnectAttempts) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      return;
+    }
+    this.state = "reconnecting";
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectInterval * Math.pow(1.5, this.reconnectAttempts - 1),
+      3e4
+      // Max 30 seconds
+    );
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+      } catch (error) {
+      }
+    }, delay);
+  }
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case "message:new":
+          this.emit("message:new", message.payload);
+          break;
+        case "message:updated":
+          this.emit("message:updated", message.payload);
+          break;
+        case "message:deleted": {
+          const { messageId, conversationId } = message.payload;
+          this.emit("message:deleted", messageId, conversationId);
+          break;
+        }
+        case "conversation:created":
+          this.emit("conversation:created", message.payload);
+          break;
+        case "conversation:updated":
+          this.emit("conversation:updated", message.payload);
+          break;
+        case "participant:joined": {
+          const { conversationId, participant } = message.payload;
+          this.emit("participant:joined", conversationId, participant);
+          break;
+        }
+        case "participant:left": {
+          const payload = message.payload;
+          this.emit("participant:left", payload.conversationId, payload.userId);
+          break;
+        }
+        case "presence:updated":
+          this.emit("presence:updated", message.payload);
+          break;
+        case "typing:start":
+          this.emit("typing:start", message.payload);
+          break;
+        case "typing:stop":
+          this.emit("typing:stop", message.payload);
+          break;
+        case "read:receipt":
+          this.emit("read:receipt", message.payload);
+          break;
+        case "call:ring":
+          this.emit("call:ring", message.payload);
+          break;
+        case "call:accept":
+          this.emit("call:accept", message.payload);
+          break;
+        case "call:reject":
+          this.emit("call:reject", message.payload);
+          break;
+        case "call:end":
+          this.emit("call:end", message.payload);
+          break;
+      }
+    } catch (error) {
+      console.error("[ChatWS] Failed to parse message:", error);
+    }
+  }
+  flushPendingMessages() {
+    while (this.pendingMessages.length > 0 && this.isConnected()) {
+      const message = this.pendingMessages.shift();
+      if (message) {
+        this.ws.send(message);
+      }
+    }
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected()) {
+        this.send("ping", {});
+      }
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  clearTimers() {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+var ChatClient = class extends EventEmitter {
+  constructor(config) {
+    super();
+    this.ws = null;
+    this.config = config;
+    this.tokenGetter = config.getToken || (() => config.token || null);
+    this.api = new ChatApi({
+      apiUrl: config.apiUrl,
+      getToken: this.tokenGetter
+    });
+    if (config.wsUrl) {
+      this.ws = new WebSocketManager({
+        url: config.wsUrl,
+        getToken: this.tokenGetter,
+        autoReconnect: config.autoReconnect ?? true,
+        reconnectInterval: config.reconnectInterval,
+        maxReconnectAttempts: config.maxReconnectAttempts
+      });
+      this.forwardWebSocketEvents();
+    }
+    if (config.autoConnect && config.wsUrl) {
+      this.connect().catch((error) => {
+        console.error("[ChatClient] Auto-connect failed:", error);
+      });
+    }
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  /**
+   * Connect to WebSocket for real-time updates
+   */
+  async connect() {
+    if (!this.ws) {
+      throw new Error("WebSocket URL not configured");
+    }
+    await this.ws.connect();
+  }
+  /**
+   * Disconnect from WebSocket
+   */
+  disconnect() {
+    this.ws?.disconnect();
+  }
+  /**
+   * Check if WebSocket is connected
+   */
+  isConnected() {
+    return this.ws?.isConnected() ?? false;
+  }
+  /**
+   * Update authentication token
+   */
+  setToken(token) {
+    this.config.token = token;
+  }
+  // ============================================================================
+  // Conversations
+  // ============================================================================
+  /**
+   * List all conversations for the current user
+   */
+  async listConversations() {
+    return this.api.listConversations();
+  }
+  /**
+   * Get a specific conversation
+   */
+  async getConversation(conversationId) {
+    return this.api.getConversation(conversationId);
+  }
+  /**
+   * Create a new conversation
+   */
+  async createConversation(params) {
+    const conversation = await this.api.createConversation(params);
+    if (this.ws?.isConnected()) {
+      this.ws.subscribeToConversation(conversation.id);
+    }
+    return conversation;
+  }
+  /**
+   * Mark conversation as read
+   */
+  async markConversationRead(conversationId) {
+    return this.api.markConversationRead(conversationId);
+  }
+  /**
+   * Leave a conversation
+   */
+  async leaveConversation(conversationId) {
+    if (this.ws?.isConnected()) {
+      this.ws.unsubscribeFromConversation(conversationId);
+    }
+    return this.api.leaveConversation(conversationId);
+  }
+  /**
+   * Subscribe to real-time updates for a conversation
+   */
+  subscribeToConversation(conversationId) {
+    this.ws?.subscribeToConversation(conversationId);
+  }
+  /**
+   * Unsubscribe from real-time updates for a conversation
+   */
+  unsubscribeFromConversation(conversationId) {
+    this.ws?.unsubscribeFromConversation(conversationId);
+  }
+  // ============================================================================
+  // Messages
+  // ============================================================================
+  /**
+   * Get messages for a conversation
+   */
+  async getMessages(conversationId, params) {
+    return this.api.getMessages(conversationId, params);
+  }
+  /**
+   * Send a message to a conversation
+   */
+  async sendMessage(conversationId, params) {
+    return this.api.sendMessage(conversationId, params);
+  }
+  /**
+   * Send a text message (convenience method)
+   */
+  async send(conversationId, content) {
+    return this.sendMessage(conversationId, { content });
+  }
+  // ============================================================================
+  // Typing Indicators
+  // ============================================================================
+  /**
+   * Send typing start indicator
+   */
+  sendTypingStart(conversationId) {
+    this.ws?.sendTypingStart(conversationId);
+  }
+  /**
+   * Send typing stop indicator
+   */
+  sendTypingStop(conversationId) {
+    this.ws?.sendTypingStop(conversationId);
+  }
+  // ============================================================================
+  // Users & Presence
+  // ============================================================================
+  /**
+   * List all users (contacts)
+   */
+  async listUsers(options) {
+    return this.api.listUsers(options);
+  }
+  /**
+   * Get online users
+   */
+  async getOnlineUsers() {
+    return this.api.getOnlineUsers();
+  }
+  /**
+   * Get current user profile
+   */
+  async getCurrentUser() {
+    return this.api.getCurrentUser();
+  }
+  /**
+   * Get a specific user
+   */
+  async getUser(userId) {
+    return this.api.getUser(userId);
+  }
+  /**
+   * Update current user's presence status
+   */
+  async updateStatus(status, statusMessage) {
+    await this.api.updateStatus(status, statusMessage);
+    this.ws?.updatePresence(status, statusMessage);
+  }
+  // ============================================================================
+  // Agents
+  // ============================================================================
+  /**
+   * Add agent to conversation
+   */
+  async addAgentToConversation(conversationId, agentConfigId, addAsParticipant = true) {
+    return this.api.addAgentToConversation(conversationId, agentConfigId, addAsParticipant);
+  }
+  /**
+   * Remove agent from conversation
+   */
+  async removeAgentFromConversation(conversationId) {
+    return this.api.removeAgentFromConversation(conversationId);
+  }
+  /**
+   * Toggle agent enabled/disabled
+   */
+  async toggleAgent(conversationId, enabled) {
+    return this.api.toggleAgent(conversationId, enabled);
+  }
+  /**
+   * List available agents
+   */
+  async listAgents() {
+    return this.api.listAgents();
+  }
+  // ============================================================================
+  // Voice/Video Calls (LiveKit)
+  // ============================================================================
+  /**
+   * Create a new voice/video room
+   *
+   * @example
+   * ```typescript
+   * const room = await chat.createRoom({ name: `call-${conversationId}` });
+   * // Use room.wsUrl and room.token with LiveKit client
+   * ```
+   */
+  async createRoom(params) {
+    return this.api.createRoom(params);
+  }
+  /**
+   * Join an existing room and get access token
+   *
+   * @example
+   * ```typescript
+   * const room = await chat.joinRoom({
+   *   roomName: `call-${conversationId}`,
+   *   participantName: 'John Doe',
+   * });
+   * // Connect to room using LiveKit client SDK with room.wsUrl and room.token
+   * ```
+   */
+  async joinRoom(params) {
+    return this.api.joinRoom(params);
+  }
+  /**
+   * Initiate a call in a conversation
+   * This notifies other participants that you're calling
+   *
+   * @example
+   * ```typescript
+   * // Start a video call
+   * const room = await chat.startCall(conversationId, 'video');
+   * // room contains { name, wsUrl, token } for LiveKit
+   * ```
+   */
+  async startCall(conversationId, callType = "audio") {
+    const roomName = `call-${conversationId}-${Date.now()}`;
+    const room = await this.api.createRoom({ name: roomName });
+    this.ws?.sendCallNotification(conversationId, "ring", callType, roomName);
+    return room;
+  }
+  /**
+   * Accept an incoming call
+   *
+   * @example
+   * ```typescript
+   * chat.on('call:ring', async ({ conversationId, roomName, callType }) => {
+   *   const room = await chat.acceptCall(conversationId, roomName);
+   *   // Connect to room using LiveKit client SDK
+   * });
+   * ```
+   */
+  async acceptCall(conversationId, roomName, participantName) {
+    const room = await this.api.joinRoom({ roomName, participantName });
+    this.ws?.sendCallNotification(conversationId, "accept", void 0, roomName);
+    return room;
+  }
+  /**
+   * Reject an incoming call
+   */
+  rejectCall(conversationId) {
+    this.ws?.sendCallNotification(conversationId, "reject");
+  }
+  /**
+   * End an ongoing call
+   */
+  endCall(conversationId) {
+    this.ws?.sendCallNotification(conversationId, "end");
+  }
+  // ============================================================================
+  // Internal
+  // ============================================================================
+  forwardWebSocketEvents() {
+    if (!this.ws) return;
+    this.ws.on("connected", () => this.emit("connected"));
+    this.ws.on("disconnected", (reason) => this.emit("disconnected", reason));
+    this.ws.on("error", (error) => this.emit("error", error));
+    this.ws.on("message:new", (event) => this.emit("message:new", event));
+    this.ws.on("message:updated", (msg) => this.emit("message:updated", msg));
+    this.ws.on("message:deleted", (msgId, convId) => this.emit("message:deleted", msgId, convId));
+    this.ws.on("conversation:created", (conv) => this.emit("conversation:created", conv));
+    this.ws.on("conversation:updated", (conv) => this.emit("conversation:updated", conv));
+    this.ws.on("participant:joined", (convId, p) => this.emit("participant:joined", convId, p));
+    this.ws.on("participant:left", (convId, userId) => this.emit("participant:left", convId, userId));
+    this.ws.on("presence:updated", (event) => this.emit("presence:updated", event));
+    this.ws.on("typing:start", (event) => this.emit("typing:start", event));
+    this.ws.on("typing:stop", (event) => this.emit("typing:stop", event));
+    this.ws.on("read:receipt", (event) => this.emit("read:receipt", event));
+    this.ws.on("call:ring", (event) => this.emit("call:ring", event));
+    this.ws.on("call:accept", (event) => this.emit("call:accept", event));
+    this.ws.on("call:reject", (event) => this.emit("call:reject", event));
+    this.ws.on("call:end", (event) => this.emit("call:end", event));
+  }
+};
+
+export { ChatApi, ChatClient, WebSocketManager };
+//# sourceMappingURL=chunk-JI6KXOLF.js.map
+//# sourceMappingURL=chunk-JI6KXOLF.js.map