@chaterafrikang/sdk 0.1.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,2119 @@
+'use strict';
+
+var eventemitter3 = require('eventemitter3');
+var uuid = require('uuid');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/core/ConnectionState.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["RECONNECTING"] = "reconnecting";
+  ConnectionState2["ERROR"] = "error";
+  return ConnectionState2;
+})(ConnectionState || {});
+
+// src/utils/logger.ts
+var Logger = class {
+  constructor(enabled = false) {
+    this.enabled = enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  debug(...args) {
+    if (this.enabled) {
+      console.debug("[ChatAfrika SDK]", ...args);
+    }
+  }
+  info(...args) {
+    if (this.enabled) {
+      console.info("[ChatAfrika SDK]", ...args);
+    }
+  }
+  warn(...args) {
+    if (this.enabled) {
+      console.warn("[ChatAfrika SDK]", ...args);
+    }
+  }
+  error(...args) {
+    if (this.enabled) {
+      console.error("[ChatAfrika SDK]", ...args);
+    }
+  }
+};
+
+// src/websocket/WebSocketClient.ts
+var isNodeEnv = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+var wsModule = null;
+var wsLoading = null;
+async function getWsModule() {
+  if (!isNodeEnv) return null;
+  if (wsModule) return wsModule;
+  if (wsLoading) return wsLoading;
+  wsLoading = (async () => {
+    try {
+      try {
+        const ws = await import('ws');
+        wsModule = ws;
+        return wsModule;
+      } catch (esmErr) {
+        if (typeof __require !== "undefined") {
+          const { createRequire } = await import('module');
+          const requireFn = createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) || __filename);
+          wsModule = requireFn("ws");
+          return wsModule;
+        }
+        throw esmErr;
+      }
+    } catch (err) {
+      return null;
+    } finally {
+      wsLoading = null;
+    }
+  })();
+  return wsLoading;
+}
+var WebSocketClient = class extends eventemitter3.EventEmitter {
+  constructor(url, options = {}) {
+    super();
+    this.ws = null;
+    this.token = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.isManuallyDisconnected = false;
+    this.isTokenExpired = false;
+    this.url = url;
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
+    this.logger = new Logger(options.debug ?? false);
+  }
+  /**
+   * Connect to the WebSocket server with authentication token
+   */
+  connect(token) {
+    if (!token || token.length === 0) {
+      const error = new Error("Token is required for connection");
+      this.emit("error", error);
+      return Promise.reject(error);
+    }
+    this.token = token;
+    this.isManuallyDisconnected = false;
+    this.isTokenExpired = false;
+    return this.attemptConnection();
+  }
+  /**
+   * Attempt a WebSocket connection
+   */
+  async attemptConnection() {
+    const wsUrl = new URL(this.url);
+    const token = this.token ?? "";
+    if (isNodeEnv) {
+      const ws = await getWsModule();
+      this.logger.debug("ws module loaded:", !!ws);
+      if (ws && ws.WebSocket) {
+        this.logger.debug("Using ws package with Authorization header");
+        return new Promise((resolve, reject) => {
+          try {
+            const wsInstance = new ws.WebSocket(wsUrl.toString(), {
+              headers: {
+                "Authorization": `Bearer ${token}`
+              }
+            });
+            this.ws = wsInstance;
+            let handshakeErrorHandled = false;
+            const errorHandler = (error) => {
+              if (handshakeErrorHandled) return;
+              handshakeErrorHandled = true;
+              const errorMsg = String(error?.message || error || "").toLowerCase();
+              if (errorMsg.includes("401") || errorMsg.includes("unauthorized") || error?.code && String(error.code).includes("401")) {
+                this.handleTokenExpiration();
+                const tokenError = new Error("Token expired or invalid. Please refresh your token and reconnect.");
+                tokenError.name = "TokenExpiredError";
+                this.emit("error", tokenError);
+                reject(tokenError);
+                return;
+              }
+            };
+            if (typeof wsInstance.addEventListener === "function") {
+              wsInstance.addEventListener("error", errorHandler);
+              wsInstance.addEventListener("open", () => {
+                wsInstance.removeEventListener("error", errorHandler);
+              });
+            } else if (typeof wsInstance.once === "function") {
+              wsInstance.once("error", errorHandler);
+              wsInstance.once("open", () => {
+              });
+            }
+            this.setupEventHandlers(resolve, reject);
+          } catch (error) {
+            this.logger.error("Failed to create ws.WebSocket:", error);
+            reject(error);
+          }
+        });
+      } else {
+        this.logger.warn("ws package not available, falling back to native WebSocket");
+      }
+    }
+    this.logger.debug("Using native WebSocket with query parameter", { url: wsUrl.toString(), hasToken: !!token });
+    return new Promise((resolve, reject) => {
+      try {
+        if (!token || token.length === 0) {
+          const error = new Error("Token is required for WebSocket connection");
+          this.logger.error(error.message);
+          reject(error);
+          return;
+        }
+        const urlWithToken = new URL(wsUrl.toString());
+        urlWithToken.searchParams.set("token", token);
+        this.ws = new globalThis.WebSocket(urlWithToken.toString());
+        this.logger.debug("WebSocket instance created", {
+          readyState: this.ws.readyState,
+          url: this.ws.url,
+          protocol: this.ws.protocol
+        });
+        const wsRef = this.ws;
+        this.setupEventHandlers(resolve, reject);
+        setTimeout(() => {
+          if (wsRef.readyState === WebSocket.CLOSED || wsRef.readyState === WebSocket.CLOSING) {
+            this.logger.warn("WebSocket closed immediately after creation", {
+              readyState: wsRef.readyState,
+              url: wsRef.url
+            });
+          }
+        }, 100);
+      } catch (error) {
+        this.logger.error("Failed to create native WebSocket:", error);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Set up WebSocket event handlers
+   */
+  setupEventHandlers(resolve, reject) {
+    if (!this.ws) return;
+    this.ws.onopen = () => {
+      this.reconnectAttempts = 0;
+      this.isTokenExpired = false;
+      const ws = this.ws;
+      if (!ws) {
+        this.logger.error("WebSocket is null in onopen handler");
+        reject(new Error("WebSocket instance lost"));
+        return;
+      }
+      this.logger.debug("WebSocket connected", {
+        readyState: ws.readyState,
+        url: ws.url,
+        protocol: ws.protocol,
+        extensions: ws.extensions
+      });
+      if (ws.readyState !== WebSocket.OPEN) {
+        this.logger.error("WebSocket readyState is not OPEN after onopen", { readyState: ws.readyState });
+        reject(new Error(`WebSocket not open: readyState=${ws.readyState}`));
+        return;
+      }
+      this.emit("connected");
+      resolve();
+    };
+    this.ws.onmessage = (event) => {
+      try {
+        const message = JSON.parse(event.data);
+        this.logger.debug("Received message:", message);
+        this.emit("message", message);
+      } catch (error) {
+        const parseError = error instanceof Error ? error : new Error("Failed to parse message");
+        this.logger.error("Failed to parse message:", parseError);
+        this.emit("error", parseError);
+      }
+    };
+    this.ws.onerror = (error) => {
+      this.logger.error("WebSocket error:", error);
+      let errorToEmit;
+      if (error instanceof Error) {
+        errorToEmit = error;
+      } else if (error && error.message) {
+        errorToEmit = error instanceof Error ? error : new Error(String(error.message));
+      } else {
+        errorToEmit = new Error("WebSocket connection error");
+      }
+      if (isNodeEnv && error && error.message) {
+        const errorMsg = String(error.message).toLowerCase();
+        if (errorMsg.includes("401") || errorMsg.includes("unauthorized")) {
+          this.handleTokenExpiration();
+          const tokenError = new Error("Token expired or invalid. Please refresh your token and reconnect.");
+          tokenError.name = "TokenExpiredError";
+          this.emit("error", tokenError);
+          reject(tokenError);
+          return;
+        }
+      }
+      this.emit("error", errorToEmit);
+    };
+    this.ws.onclose = (event) => {
+      this.logger.debug("WebSocket closed:", {
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (event.code === 1006) {
+        this.logger.warn("Abnormal closure (1006) - connection closed without proper handshake. Possible causes: network issue, server closed connection, CORS issue, or protocol mismatch.");
+      }
+      const isAuthFailure = event.code === 1008 || event.code === 1002 || event.reason && event.reason.toLowerCase().includes("unauthorized") || event.reason && event.reason.toLowerCase().includes("401");
+      if (isAuthFailure) {
+        this.handleTokenExpiration();
+        const tokenError = new Error("Token expired or invalid. Please refresh your token and reconnect.");
+        tokenError.name = "TokenExpiredError";
+        this.emit("error", tokenError);
+        this.emit("disconnected", { code: event.code, reason: event.reason, tokenExpired: true });
+        return;
+      }
+      this.emit("disconnected", { code: event.code, reason: event.reason });
+      if (!this.isManuallyDisconnected && !this.isTokenExpired && this.autoReconnect) {
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.scheduleReconnect();
+        } else {
+          this.logger.warn("Max reconnection attempts reached");
+          this.emit("error", new Error("Max reconnection attempts reached"));
+        }
+      } else if (this.isTokenExpired) {
+        this.logger.warn("Not reconnecting: token is expired");
+      }
+    };
+  }
+  /**
+   * Handle token expiration - stop reconnection attempts
+   */
+  handleTokenExpiration() {
+    this.isTokenExpired = true;
+    this.autoReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    this.isManuallyDisconnected = true;
+    this.autoReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.logger.debug("WebSocket disconnected");
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      const error = new Error("WebSocket is not connected");
+      this.logger.error(error.message);
+      this.emit("error", error);
+      throw error;
+    }
+    try {
+      const messageStr = JSON.stringify(message);
+      this.logger.debug("Sending message:", message);
+      this.ws.send(messageStr);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to send message");
+      this.logger.error("Send error:", sendError);
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+  /**
+   * Check if the WebSocket is connected
+   */
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get current reconnection attempt count
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Schedule a reconnection attempt with exponential backoff
+   * Backoff: 1s → 2s → 5s → 10s (max)
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer || !this.token) {
+      return;
+    }
+    this.reconnectAttempts++;
+    const backoffDelays = [1e3, 2e3, 5e3, 1e4];
+    const delay = backoffDelays[Math.min(this.reconnectAttempts - 1, backoffDelays.length - 1)];
+    this.logger.debug(`Scheduling reconnect attempt ${this.reconnectAttempts} in ${delay}ms`);
+    this.emit("reconnecting", { attempt: this.reconnectAttempts, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.attemptConnection().catch(() => {
+      });
+    }, delay);
+  }
+};
+
+// src/auth/TokenManager.ts
+var TokenManager = class {
+  constructor() {
+    this.token = null;
+  }
+  /**
+   * Set the SDK token
+   */
+  setToken(token) {
+    if (!this.isValidFormat(token)) {
+      throw new Error("Invalid token format");
+    }
+    this.token = token;
+  }
+  /**
+   * Get the current SDK token
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Check if a token is set
+   */
+  hasToken() {
+    return this.token !== null && this.token.length > 0;
+  }
+  /**
+   * Clear the token
+   */
+  clearToken() {
+    this.token = null;
+  }
+  /**
+   * Replace the current token with a new one (token rotation)
+   */
+  rotateToken(newToken) {
+    if (!this.isValidFormat(newToken)) {
+      throw new Error("Invalid token format");
+    }
+    this.token = newToken;
+  }
+  /**
+   * Validate token format (basic validation)
+   */
+  isValidFormat(token) {
+    return typeof token === "string" && token.length > 0;
+  }
+  /**
+   * Validate that a token is present before operations
+   */
+  validateTokenPresence() {
+    if (!this.hasToken()) {
+      throw new Error("Token is required but not set");
+    }
+  }
+};
+
+// src/messages/Message.ts
+var MessageFactory = class {
+  /**
+   * Create an optimistic message (client-generated, not yet confirmed by server)
+   */
+  static createOptimistic(conversationId, messageId, content, messageType = "text", metadata) {
+    return {
+      id: messageId,
+      conversationId,
+      content,
+      messageType,
+      optimistic: true,
+      receiptState: "sent",
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata
+    };
+  }
+  /**
+   * Create a message from server payload (confirmed message)
+   */
+  static fromServerPayload(conversationId, payload) {
+    return {
+      id: payload.message_id,
+      conversationId,
+      content: payload.content,
+      senderId: payload.sender_id,
+      senderType: payload.sender_type,
+      messageType: payload.message_type === "system" ? "system" : "text",
+      optimistic: false,
+      receiptState: "sent",
+      createdAt: payload.sent_at ? new Date(payload.sent_at) : /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Convert an optimistic message to confirmed (reconciliation)
+   */
+  static confirmOptimistic(optimisticMessage, serverPayload) {
+    return {
+      ...optimisticMessage,
+      optimistic: false,
+      senderId: serverPayload.sender_id,
+      senderType: serverPayload.sender_type,
+      receiptState: optimisticMessage.receiptState ?? "sent",
+      createdAt: serverPayload.sent_at ? new Date(serverPayload.sent_at) : optimisticMessage.createdAt
+    };
+  }
+  /**
+   * Update receipt state on a message (immutable update)
+   */
+  static updateReceiptState(message, receiptState) {
+    return {
+      ...message,
+      receiptState
+    };
+  }
+};
+var ReceiptManager = class extends eventemitter3.EventEmitter {
+  constructor(debug = false) {
+    super();
+    /**
+     * Track receipt state per message
+     * Map<messageId, ReceiptState>
+     */
+    this.receiptState = /* @__PURE__ */ new Map();
+    this.logger = new Logger(debug);
+  }
+  /**
+   * Get receipt state for a message
+   */
+  getReceiptState(messageId) {
+    return this.receiptState.get(messageId);
+  }
+  /**
+   * Handle a delivered receipt
+   * 
+   * Rules:
+   * - Only update if current state < delivered
+   * - Ignore duplicate or regressive updates
+   */
+  handleDelivered(messageId, userId) {
+    if (!messageId) {
+      this.logger.warn("Invalid delivered receipt: missing messageId");
+      return false;
+    }
+    const currentState = this.receiptState.get(messageId) ?? "sent";
+    if (this.compareStates(currentState, "delivered") < 0) {
+      this.receiptState.set(messageId, "delivered");
+      this.emit("receipt", {
+        messageId,
+        state: "delivered",
+        userId
+      });
+      this.logger.debug("Receipt delivered:", messageId);
+      return true;
+    } else {
+      this.logger.debug("Delivered receipt ignored (already delivered or read):", messageId);
+      return false;
+    }
+  }
+  /**
+   * Handle a read receipt
+   * 
+   * Rules:
+   * - Only update if current state < read
+   * - Ignore duplicate or regressive updates
+   */
+  handleRead(messageId, userId) {
+    if (!messageId) {
+      this.logger.warn("Invalid read receipt: missing messageId");
+      return false;
+    }
+    const currentState = this.receiptState.get(messageId) ?? "sent";
+    if (this.compareStates(currentState, "read") < 0) {
+      this.receiptState.set(messageId, "read");
+      this.emit("receipt", {
+        messageId,
+        state: "read",
+        userId
+      });
+      this.logger.debug("Receipt read:", messageId);
+      return true;
+    } else {
+      this.logger.debug("Read receipt ignored (already read):", messageId);
+      return false;
+    }
+  }
+  /**
+   * Compare two receipt states
+   * Returns: -1 if a < b, 0 if a === b, 1 if a > b
+   */
+  compareStates(a, b) {
+    const order = ["sent", "delivered", "read"];
+    const aIndex = order.indexOf(a);
+    const bIndex = order.indexOf(b);
+    if (aIndex === -1 || bIndex === -1) {
+      return 0;
+    }
+    return aIndex - bIndex;
+  }
+  /**
+   * Clear receipt state for a conversation
+   * Note: We track by messageId, so we need to clear all messages for a conversation
+   * This is called when leaving a conversation
+   */
+  clearConversation(conversationId, messageIds) {
+    let cleared = 0;
+    for (const messageId of messageIds) {
+      if (this.receiptState.has(messageId)) {
+        this.receiptState.delete(messageId);
+        cleared++;
+      }
+    }
+    if (cleared > 0) {
+      this.logger.debug("Cleared receipt state for conversation:", conversationId, `(${cleared} messages)`);
+    }
+  }
+  /**
+   * Clear receipt state for a specific message
+   */
+  clearMessage(messageId) {
+    if (this.receiptState.delete(messageId)) {
+      this.logger.debug("Cleared receipt state for message:", messageId);
+    }
+  }
+  /**
+   * Clear all receipt state
+   */
+  clear() {
+    this.receiptState.clear();
+    this.logger.debug("Cleared all receipt state");
+  }
+};
+
+// src/messages/MessageManager.ts
+var MessageManager = class extends eventemitter3.EventEmitter {
+  constructor(debug = false) {
+    super();
+    /**
+     * Track seen message IDs per conversation to prevent duplicates
+     * Map<conversationId, Set<message_id>>
+     */
+    this.seenMessageIds = /* @__PURE__ */ new Map();
+    /**
+     * Track optimistic messages that are waiting for server confirmation
+     * Map<conversationId, Map<message_id, Message>>
+     */
+    this.optimisticMessages = /* @__PURE__ */ new Map();
+    /**
+     * Track confirmed messages for receipt updates
+     * Map<conversationId, Map<message_id, Message>>
+     */
+    this.confirmedMessages = /* @__PURE__ */ new Map();
+    this.logger = new Logger(debug);
+    this.receiptManager = new ReceiptManager(debug);
+    this.receiptManager.on("receipt", (event) => {
+      this.updateMessageReceiptState(event);
+    });
+  }
+  /**
+   * Create an optimistic message and emit it immediately
+   * 
+   * @returns The created optimistic message
+   */
+  createOptimisticMessage(conversationId, messageId, content, messageType = "text", metadata) {
+    const message = MessageFactory.createOptimistic(
+      conversationId,
+      messageId,
+      content,
+      messageType,
+      metadata
+    );
+    this.trackOptimisticMessage(conversationId, messageId, message);
+    this.trackMessageId(conversationId, messageId);
+    this.emit("message", message);
+    this.logger.debug("Created optimistic message:", messageId);
+    return message;
+  }
+  /**
+   * Handle an incoming message from the server
+   * 
+   * This method:
+   * - Checks for duplicates
+   * - Reconciles optimistic messages if message_id matches
+   * - Emits confirmed messages
+   * 
+   * @returns The message (reconciled if optimistic, new if not), or null if duplicate
+   */
+  handleIncomingMessage(conversationId, serverPayload) {
+    const messageId = serverPayload.message_id;
+    const optimisticMessage = this.getOptimisticMessage(conversationId, messageId);
+    if (optimisticMessage) {
+      const reconciledMessage = this.reconcileOptimisticMessage(optimisticMessage, serverPayload);
+      this.removeOptimisticMessage(conversationId, messageId);
+      this.trackMessageId(conversationId, messageId);
+      this.trackConfirmedMessage(conversationId, messageId, reconciledMessage);
+      return reconciledMessage;
+    }
+    if (this.hasSeenMessage(conversationId, messageId)) {
+      this.logger.debug("Duplicate message ignored:", messageId);
+      return null;
+    }
+    this.trackMessageId(conversationId, messageId);
+    const message = MessageFactory.fromServerPayload(conversationId, serverPayload);
+    this.trackConfirmedMessage(conversationId, messageId, message);
+    this.emit("message", message);
+    this.logger.debug("Handled incoming message:", messageId);
+    return message;
+  }
+  /**
+   * Handle a receipt update
+   * 
+   * This method:
+   * - Routes receipt to ReceiptManager
+   * - Updates message receipt state if message exists
+   * - Emits updated message
+   */
+  handleReceipt(_conversationId, messageId, receiptState, userId) {
+    if (receiptState === "delivered") {
+      this.receiptManager.handleDelivered(messageId, userId);
+    } else if (receiptState === "read") {
+      this.receiptManager.handleRead(messageId, userId);
+    }
+  }
+  /**
+   * Update message receipt state and emit updated message
+   */
+  updateMessageReceiptState(event) {
+    for (const [, messages] of this.confirmedMessages.entries()) {
+      const message = messages.get(event.messageId);
+      if (message) {
+        const updatedMessage = MessageFactory.updateReceiptState(
+          message,
+          event.state
+        );
+        messages.set(event.messageId, updatedMessage);
+        this.emit("message", updatedMessage);
+        this.logger.debug("Updated message receipt state:", event.messageId, event.state);
+        return;
+      }
+    }
+    for (const [, messages] of this.optimisticMessages.entries()) {
+      const message = messages.get(event.messageId);
+      if (message) {
+        const updatedMessage = MessageFactory.updateReceiptState(
+          message,
+          event.state
+        );
+        messages.set(event.messageId, updatedMessage);
+        this.emit("message", updatedMessage);
+        this.logger.debug("Updated optimistic message receipt state:", event.messageId, event.state);
+        return;
+      }
+    }
+    this.logger.warn("Receipt for unknown message:", event.messageId);
+  }
+  /**
+   * Reconcile an optimistic message with a server confirmation
+   * 
+   * This is called when we receive a server message with the same message_id
+   * as an optimistic message we previously created.
+   * 
+   * @returns The reconciled (confirmed) message
+   */
+  reconcileOptimisticMessage(optimisticMessage, serverPayload) {
+    const confirmedMessage = MessageFactory.confirmOptimistic(optimisticMessage, serverPayload);
+    this.emit("message", confirmedMessage);
+    this.logger.debug("Reconciled optimistic message:", optimisticMessage.id);
+    return confirmedMessage;
+  }
+  /**
+   * Check if we've already seen a message ID for a conversation
+   */
+  hasSeenMessage(conversationId, messageId) {
+    const seenIds = this.seenMessageIds.get(conversationId);
+    return seenIds?.has(messageId) ?? false;
+  }
+  /**
+   * Track a message ID for a conversation (for deduplication)
+   */
+  trackMessageId(conversationId, messageId) {
+    let seenIds = this.seenMessageIds.get(conversationId);
+    if (!seenIds) {
+      seenIds = /* @__PURE__ */ new Set();
+      this.seenMessageIds.set(conversationId, seenIds);
+    }
+    seenIds.add(messageId);
+  }
+  /**
+   * Track an optimistic message for later reconciliation
+   */
+  trackOptimisticMessage(conversationId, messageId, message) {
+    let conversationOptimistic = this.optimisticMessages.get(conversationId);
+    if (!conversationOptimistic) {
+      conversationOptimistic = /* @__PURE__ */ new Map();
+      this.optimisticMessages.set(conversationId, conversationOptimistic);
+    }
+    conversationOptimistic.set(messageId, message);
+  }
+  /**
+   * Get an optimistic message by ID
+   */
+  getOptimisticMessage(conversationId, messageId) {
+    const conversationOptimistic = this.optimisticMessages.get(conversationId);
+    return conversationOptimistic?.get(messageId);
+  }
+  /**
+   * Remove an optimistic message from tracking
+   */
+  removeOptimisticMessage(conversationId, messageId) {
+    const conversationOptimistic = this.optimisticMessages.get(conversationId);
+    if (conversationOptimistic) {
+      conversationOptimistic.delete(messageId);
+      if (conversationOptimistic.size === 0) {
+        this.optimisticMessages.delete(conversationId);
+      }
+    }
+  }
+  /**
+   * Track a confirmed message for receipt updates
+   */
+  trackConfirmedMessage(conversationId, messageId, message) {
+    let conversationMessages = this.confirmedMessages.get(conversationId);
+    if (!conversationMessages) {
+      conversationMessages = /* @__PURE__ */ new Map();
+      this.confirmedMessages.set(conversationId, conversationMessages);
+    }
+    conversationMessages.set(messageId, message);
+  }
+  /**
+   * Get all message IDs for a conversation (for receipt clearing)
+   */
+  getMessageIds(conversationId) {
+    const confirmed = this.confirmedMessages.get(conversationId);
+    const optimistic = this.optimisticMessages.get(conversationId);
+    const ids = /* @__PURE__ */ new Set();
+    if (confirmed) {
+      for (const id of confirmed.keys()) {
+        ids.add(id);
+      }
+    }
+    if (optimistic) {
+      for (const id of optimistic.keys()) {
+        ids.add(id);
+      }
+    }
+    return Array.from(ids);
+  }
+  /**
+   * Clear tracked message IDs and optimistic messages for a conversation
+   */
+  clearConversation(conversationId) {
+    this.seenMessageIds.delete(conversationId);
+    this.optimisticMessages.delete(conversationId);
+    const messageIds = this.getMessageIds(conversationId);
+    this.receiptManager.clearConversation(conversationId, messageIds);
+    this.confirmedMessages.delete(conversationId);
+    this.logger.debug("Cleared message tracking for conversation:", conversationId);
+  }
+  /**
+   * Clear all tracked message IDs and optimistic messages
+   */
+  clear() {
+    this.seenMessageIds.clear();
+    this.optimisticMessages.clear();
+    this.confirmedMessages.clear();
+    this.receiptManager.clear();
+    this.logger.debug("Cleared all message tracking");
+  }
+};
+var TypingManager = class extends eventemitter3.EventEmitter {
+  // 5 seconds
+  constructor(debug = false) {
+    super();
+    /**
+     * Track active typing timers per conversation per user
+     * Map<conversationId, Map<userId, timeout>>
+     */
+    this.typingTimers = /* @__PURE__ */ new Map();
+    /**
+     * Track who is currently typing per conversation
+     * Map<conversationId, Set<userId>>
+     */
+    this.activeTyping = /* @__PURE__ */ new Map();
+    this.TYPING_TIMEOUT_MS = 5e3;
+    this.logger = new Logger(debug);
+  }
+  /**
+   * Handle a typing_start event
+   * 
+   * Rules:
+   * - Emit only once per user until stopped
+   * - Restart timeout if typing_start repeats
+   */
+  handleTypingStart(conversationId, userId) {
+    if (!conversationId || !userId) {
+      this.logger.warn("Invalid typing_start: missing conversationId or userId");
+      return;
+    }
+    let conversationTyping = this.activeTyping.get(conversationId);
+    if (!conversationTyping) {
+      conversationTyping = /* @__PURE__ */ new Set();
+      this.activeTyping.set(conversationId, conversationTyping);
+    }
+    let conversationTimers = this.typingTimers.get(conversationId);
+    if (!conversationTimers) {
+      conversationTimers = /* @__PURE__ */ new Map();
+      this.typingTimers.set(conversationId, conversationTimers);
+    }
+    const wasTyping = conversationTyping.has(userId);
+    const existingTimer = conversationTimers.get(userId);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    conversationTyping.add(userId);
+    const timer = setTimeout(() => {
+      this.handleTypingStop(conversationId, userId);
+    }, this.TYPING_TIMEOUT_MS);
+    conversationTimers.set(userId, timer);
+    if (!wasTyping) {
+      this.emit("typing", {
+        conversationId,
+        userId,
+        state: "start"
+      });
+      this.logger.debug("Typing started:", conversationId, userId);
+    } else {
+      this.logger.debug("Typing timer restarted:", conversationId, userId);
+    }
+  }
+  /**
+   * Handle a typing_stop event
+   * 
+   * Rules:
+   * - Emit only if user was typing
+   */
+  handleTypingStop(conversationId, userId) {
+    if (!conversationId || !userId) {
+      this.logger.warn("Invalid typing_stop: missing conversationId or userId");
+      return;
+    }
+    const conversationTyping = this.activeTyping.get(conversationId);
+    const conversationTimers = this.typingTimers.get(conversationId);
+    if (!conversationTyping || !conversationTyping.has(userId)) {
+      this.logger.debug("Typing stop ignored (user not typing):", conversationId, userId);
+      return;
+    }
+    const timer = conversationTimers?.get(userId);
+    if (timer) {
+      clearTimeout(timer);
+      conversationTimers?.delete(userId);
+    }
+    conversationTyping.delete(userId);
+    if (conversationTyping.size === 0) {
+      this.activeTyping.delete(conversationId);
+    }
+    if (conversationTimers && conversationTimers.size === 0) {
+      this.typingTimers.delete(conversationId);
+    }
+    this.emit("typing", {
+      conversationId,
+      userId,
+      state: "stop"
+    });
+    this.logger.debug("Typing stopped:", conversationId, userId);
+  }
+  /**
+   * Clear all typing state for a conversation
+   */
+  clearConversation(conversationId) {
+    const conversationTyping = this.activeTyping.get(conversationId);
+    const conversationTimers = this.typingTimers.get(conversationId);
+    if (conversationTyping) {
+      for (const userId of conversationTyping) {
+        this.emit("typing", {
+          conversationId,
+          userId,
+          state: "stop"
+        });
+      }
+      this.activeTyping.delete(conversationId);
+    }
+    if (conversationTimers) {
+      for (const timer of conversationTimers.values()) {
+        clearTimeout(timer);
+      }
+      this.typingTimers.delete(conversationId);
+    }
+    this.logger.debug("Cleared typing state for conversation:", conversationId);
+  }
+  /**
+   * Clear all typing state
+   */
+  clear() {
+    for (const conversationTimers of this.typingTimers.values()) {
+      for (const timer of conversationTimers.values()) {
+        clearTimeout(timer);
+      }
+    }
+    this.typingTimers.clear();
+    this.activeTyping.clear();
+    this.logger.debug("Cleared all typing state");
+  }
+  /**
+   * Get currently typing users for a conversation
+   */
+  getTypingUsers(conversationId) {
+    const conversationTyping = this.activeTyping.get(conversationId);
+    return conversationTyping ? Array.from(conversationTyping) : [];
+  }
+};
+
+// src/conversations/Conversation.ts
+var Conversation = class extends eventemitter3.EventEmitter {
+  constructor(conversationId, debug = false) {
+    super();
+    this._isJoined = false;
+    this.id = conversationId;
+    this.messageManager = new MessageManager(debug);
+    this.typingManager = new TypingManager(debug);
+    this.messageManager.on("message", (message) => {
+      if (message.conversationId === this.id) {
+        this.emit("message", message);
+      }
+    });
+    this.messageManager.on("receipt", (event) => {
+      this.emit("receipt", event);
+    });
+    this.typingManager.on("typing", (event) => {
+      if (event.conversationId === this.id) {
+        this.emit("typing", {
+          userId: event.userId,
+          state: event.state
+        });
+      }
+    });
+  }
+  /**
+   * Check if this conversation is currently joined
+   */
+  get isJoined() {
+    return this._isJoined;
+  }
+  /**
+   * Set the send message handler (called by ConversationManager)
+   */
+  setSendMessageHandler(handler) {
+    this.sendMessageHandler = handler;
+  }
+  /**
+   * Set the send typing handler (called by ConversationManager)
+   */
+  setSendTypingHandler(handler) {
+    this.sendTypingHandler = handler;
+  }
+  /**
+   * Mark conversation as joined
+   */
+  markJoined() {
+    if (!this._isJoined) {
+      this._isJoined = true;
+      this.emit("joined", { conversation_id: this.id });
+    }
+  }
+  /**
+   * Mark conversation as left
+   */
+  markLeft() {
+    if (this._isJoined) {
+      this._isJoined = false;
+      this.emit("left", { conversation_id: this.id });
+    }
+  }
+  /**
+   * Send a message to this conversation
+   * 
+   * This method:
+   * 1. Generates a message_id (UUID v4)
+   * 2. Creates an optimistic Message
+   * 3. Emits the optimistic message immediately
+   * 4. Sends the message via transport
+   */
+  sendMessage(content, messageType = "text", metadata) {
+    if (!this.sendMessageHandler) {
+      const error = new Error("Conversation is not connected. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    if (!this._isJoined) {
+      const error = new Error("Conversation is not joined. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    const messageId = uuid.v4();
+    this.messageManager.createOptimisticMessage(
+      this.id,
+      messageId,
+      content,
+      messageType,
+      metadata
+    );
+    const protocolMessage = {
+      type: "message",
+      conversation_id: this.id,
+      payload: {
+        message_id: messageId,
+        content,
+        message_type: messageType
+      }
+    };
+    try {
+      this.sendMessageHandler(protocolMessage);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to send message");
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+  /**
+   * Handle an incoming message from the server
+   * Called by ConversationManager when routing messages
+   */
+  handleIncomingMessage(payload) {
+    this.messageManager.handleIncomingMessage(this.id, payload);
+  }
+  /**
+   * Handle a receipt update
+   * Called by ConversationManager when routing receipt messages
+   */
+  handleReceipt(messageId, receiptState, userId) {
+    this.messageManager.handleReceipt(this.id, messageId, receiptState, userId);
+  }
+  /**
+   * Handle a typing event from the server
+   * Called by ConversationManager when routing typing messages
+   */
+  handleTyping(payload) {
+    if (payload.state === "start") {
+      this.typingManager.handleTypingStart(this.id, payload.user_id);
+    } else if (payload.state === "stop") {
+      this.typingManager.handleTypingStop(this.id, payload.user_id);
+    }
+  }
+  /**
+   * Emit a presence event (called by ConversationManager when routing)
+   * Note: Presence is SDK-global, but we emit it here for convenience
+   */
+  emitPresence(payload) {
+    this.emit("presence", {
+      userId: payload.user_id,
+      state: payload.state
+    });
+  }
+  /**
+   * Clear message tracking for this conversation
+   */
+  clearMessages() {
+    this.messageManager.clearConversation(this.id);
+  }
+  /**
+   * Clear typing state for this conversation
+   */
+  clearTyping() {
+    this.typingManager.clearConversation(this.id);
+  }
+  /**
+   * Start typing indicator
+   * 
+   * This method sends a typing_start message to the server.
+   * The TypingManager will handle debouncing and auto-expiry.
+   */
+  startTyping() {
+    if (!this.sendTypingHandler) {
+      const error = new Error("Conversation is not connected. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    if (!this._isJoined) {
+      const error = new Error("Conversation is not joined. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    const typingMessage = {
+      type: "typing_start",
+      conversation_id: this.id
+    };
+    try {
+      this.sendTypingHandler(typingMessage);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to send typing_start");
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+  /**
+   * Stop typing indicator
+   * 
+   * This method sends a typing_stop message to the server.
+   */
+  stopTyping() {
+    if (!this.sendTypingHandler) {
+      const error = new Error("Conversation is not connected. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    if (!this._isJoined) {
+      const error = new Error("Conversation is not joined. Call join() first.");
+      this.emit("error", error);
+      throw error;
+    }
+    const typingMessage = {
+      type: "typing_stop",
+      conversation_id: this.id
+    };
+    try {
+      this.sendTypingHandler(typingMessage);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to send typing_stop");
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+};
+
+// src/conversations/ConversationManager.ts
+var ConversationManager = class extends eventemitter3.EventEmitter {
+  constructor(sendMessageHandler, debug = false, supportMessageHandler, sendTypingHandler) {
+    super();
+    this.conversations = /* @__PURE__ */ new Map();
+    this.sendMessageHandler = sendMessageHandler;
+    this.sendTypingHandler = sendTypingHandler;
+    this.supportMessageHandler = supportMessageHandler;
+    this.debug = debug;
+    this.logger = new Logger(debug);
+  }
+  /**
+   * Set the support message handler (called by ChatAfrika)
+   */
+  setSupportMessageHandler(handler) {
+    this.supportMessageHandler = handler;
+  }
+  /**
+   * Set the send typing handler (called by ChatAfrika)
+   */
+  setSendTypingHandler(handler) {
+    this.sendTypingHandler = handler;
+    for (const conversation of this.conversations.values()) {
+      conversation.setSendTypingHandler(handler);
+    }
+  }
+  /**
+   * Get or create a Conversation instance
+   * Conversations are lazy-created
+   */
+  get(conversationId) {
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    let conversation = this.conversations.get(conversationId);
+    if (!conversation) {
+      conversation = new Conversation(conversationId, this.debug);
+      if (this.sendMessageHandler) {
+        conversation.setSendMessageHandler(this.sendMessageHandler);
+      }
+      if (this.sendTypingHandler) {
+        conversation.setSendTypingHandler(this.sendTypingHandler);
+      }
+      this.conversations.set(conversationId, conversation);
+      this.logger.debug("Created conversation instance:", conversationId);
+    }
+    return conversation;
+  }
+  /**
+   * Check if a conversation instance exists
+   */
+  has(conversationId) {
+    return this.conversations.has(conversationId);
+  }
+  /**
+   * Join a conversation
+   * This delegates to the transport layer (ChatAfrika)
+   */
+  async join(conversationId, joinHandler) {
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    this.get(conversationId);
+    await joinHandler(conversationId);
+    this.logger.debug("Join requested for conversation:", conversationId);
+  }
+  /**
+   * Leave a conversation
+   * This delegates to the transport layer (ChatAfrika)
+   */
+  async leave(conversationId, leaveHandler) {
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    const conversation = this.conversations.get(conversationId);
+    if (conversation) {
+      conversation.clearTyping();
+      await leaveHandler(conversationId);
+      conversation.markLeft();
+      this.logger.debug("Left conversation:", conversationId);
+    } else {
+      await leaveHandler(conversationId);
+      this.logger.warn("Attempted to leave unknown conversation:", conversationId);
+    }
+  }
+  /**
+   * Route an incoming protocol message to the appropriate Conversation
+   * 
+   * Messages are routed through MessageManager for lifecycle handling.
+   * Typing events are routed through TypingManager.
+   * Only messages for joined conversations are processed.
+   */
+  routeIncomingMessage(message) {
+    let conversationId;
+    switch (message.type) {
+      case "joined":
+        conversationId = message.payload?.conversation_id || message.conversation_id;
+        if (conversationId) {
+          const conversation = this.get(conversationId);
+          conversation.markJoined();
+        }
+        break;
+      case "message":
+        conversationId = message.conversation_id;
+        if (conversationId) {
+          const conversation = this.conversations.get(conversationId);
+          if (conversation) {
+            if (conversation.isJoined) {
+              conversation.handleIncomingMessage(message.payload);
+            } else {
+              this.logger.warn("Received message for conversation that is not joined:", conversationId);
+            }
+          } else {
+            this.logger.warn("Received message for unknown conversation:", conversationId);
+          }
+        }
+        break;
+      case "typing":
+        conversationId = message.conversation_id;
+        if (conversationId) {
+          const conversation = this.conversations.get(conversationId);
+          if (conversation) {
+            if (conversation.isJoined) {
+              conversation.handleTyping(message.payload);
+            } else {
+              this.logger.warn("Received typing indicator for conversation that is not joined:", conversationId);
+            }
+          } else {
+            this.logger.warn("Received typing indicator for unknown conversation:", conversationId);
+          }
+        }
+        break;
+      case "receipt":
+        conversationId = message.conversation_id;
+        if (conversationId) {
+          const conversation = this.conversations.get(conversationId);
+          if (conversation) {
+            if (conversation.isJoined) {
+              const receiptMsg = message;
+              conversation.handleReceipt(
+                receiptMsg.payload.message_id,
+                receiptMsg.payload.state,
+                receiptMsg.payload.user_id
+              );
+            } else {
+              this.logger.warn("Received receipt for conversation that is not joined:", conversationId);
+            }
+          } else {
+            this.logger.warn("Received receipt for unknown conversation:", conversationId);
+          }
+        }
+        break;
+      case "support":
+        break;
+      case "presence":
+        conversationId = message.conversation_id;
+        if (conversationId) {
+          const conversation = this.conversations.get(conversationId);
+          if (conversation && conversation.isJoined) {
+            conversation.emitPresence(message.payload);
+          }
+        }
+        break;
+      case "error":
+        this.logger.error("Received error message:", message.error);
+        break;
+    }
+  }
+  /**
+   * Route a support protocol message to SupportManager
+   */
+  routeSupportMessage(message) {
+    if (!this.supportMessageHandler) {
+      this.logger.warn("Support message handler not set, ignoring support message");
+      return;
+    }
+    const conversationId = message.conversation_id;
+    if (!conversationId) {
+      this.logger.warn("Support message missing conversation_id");
+      return;
+    }
+    const eventType = message.payload?.event;
+    if (!eventType) {
+      this.logger.warn("Support message missing event type");
+      return;
+    }
+    this.supportMessageHandler(conversationId, eventType, message.payload);
+  }
+  /**
+   * Remove a conversation instance
+   */
+  remove(conversationId) {
+    const conversation = this.conversations.get(conversationId);
+    if (conversation) {
+      conversation.markLeft();
+      conversation.clearMessages();
+      conversation.clearTyping();
+      this.conversations.delete(conversationId);
+      this.logger.debug("Removed conversation instance:", conversationId);
+    }
+  }
+  /**
+   * Get all conversation IDs
+   */
+  getAllIds() {
+    return Array.from(this.conversations.keys());
+  }
+  /**
+   * Clear all conversations
+   */
+  clear() {
+    for (const conversation of this.conversations.values()) {
+      conversation.markLeft();
+      conversation.clearMessages();
+      conversation.clearTyping();
+    }
+    this.conversations.clear();
+    this.logger.debug("Cleared all conversations");
+  }
+};
+var PresenceManager = class extends eventemitter3.EventEmitter {
+  constructor(debug = false) {
+    super();
+    /**
+     * Track current presence state per user
+     * Map<userId, "online" | "offline">
+     */
+    this.presenceState = /* @__PURE__ */ new Map();
+    this.logger = new Logger(debug);
+  }
+  /**
+   * Handle a presence event
+   * 
+   * Rules:
+   * - Emit only on state change
+   * - Ignore duplicate online/online or offline/offline events
+   */
+  handlePresence(userId, state) {
+    if (!userId) {
+      this.logger.warn("Invalid presence event: missing userId");
+      return;
+    }
+    if (state !== "online" && state !== "offline") {
+      this.logger.warn("Invalid presence state:", state);
+      return;
+    }
+    const currentState = this.presenceState.get(userId);
+    if (currentState !== state) {
+      this.presenceState.set(userId, state);
+      this.emit("presence", {
+        userId,
+        state
+      });
+      this.logger.debug("Presence changed:", userId, state);
+    } else {
+      this.logger.debug("Duplicate presence event ignored:", userId, state);
+    }
+  }
+  /**
+   * Get current presence state for a user
+   */
+  getPresence(userId) {
+    return this.presenceState.get(userId);
+  }
+  /**
+   * Get presence state for multiple users
+   */
+  getPresences(userIds) {
+    const result = /* @__PURE__ */ new Map();
+    for (const userId of userIds) {
+      const state = this.presenceState.get(userId);
+      if (state) {
+        result.set(userId, state);
+      }
+    }
+    return result;
+  }
+  /**
+   * Clear presence for a user
+   */
+  clearPresence(userId) {
+    const hadState = this.presenceState.has(userId);
+    this.presenceState.delete(userId);
+    if (hadState) {
+      this.logger.debug("Cleared presence for user:", userId);
+    }
+  }
+  /**
+   * Clear all presence state
+   */
+  clear() {
+    this.presenceState.clear();
+    this.logger.debug("Cleared all presence state");
+  }
+};
+var SupportSession = class extends eventemitter3.EventEmitter {
+  constructor(conversationId, conversation, role, debug = false) {
+    super();
+    this.botActive = false;
+    this.status = "queued";
+    this.conversationId = conversationId;
+    this.conversation = conversation;
+    this.role = role;
+    this.logger = new Logger(debug);
+    this.conversation.on("message", (msg) => this.emit("message", msg));
+    this.conversation.on("typing", (event) => this.emit("typing", event));
+    this.conversation.on("presence", (event) => this.emit("presence", event));
+    this.conversation.on("joined", (event) => this.emit("joined", event));
+    this.conversation.on("left", (event) => this.emit("left", event));
+    this.conversation.on("error", (error) => this.emit("error", error));
+  }
+  /**
+   * Get the underlying Conversation instance
+   */
+  getConversation() {
+    return this.conversation;
+  }
+  /**
+   * Check if this session is for a customer
+   */
+  isCustomer() {
+    return this.role === "customer";
+  }
+  /**
+   * Check if this session is for an agent
+   */
+  isAgent() {
+    return this.role === "agent";
+  }
+  /**
+   * Get the current role
+   */
+  getRole() {
+    return this.role;
+  }
+  /**
+   * Check if bot is currently active
+   */
+  isBotActive() {
+    return this.botActive;
+  }
+  /**
+   * Get the assigned agent ID (if any)
+   */
+  getAssignedAgent() {
+    return this.assignedAgentId;
+  }
+  /**
+   * Get the current status
+   */
+  getStatus() {
+    return this.status;
+  }
+  /**
+   * Handle assignment of an agent
+   */
+  handleAssigned(agentId) {
+    if (this.assignedAgentId === agentId) {
+      return;
+    }
+    const previousAgentId = this.assignedAgentId;
+    const wasAssigned = previousAgentId !== void 0;
+    this.assignedAgentId = agentId;
+    if (this.status === "queued") {
+      this.status = "assigned";
+    } else if (this.status === "assigned" || this.status === "active") ;
+    if (!wasAssigned) {
+      this.emit("assigned", { agentId });
+      this.logger.debug("Support session assigned:", this.conversationId, agentId);
+    } else {
+      this.emit("assigned", { agentId, previousAgentId });
+      this.logger.debug("Support session reassigned:", this.conversationId, agentId, "from", previousAgentId);
+    }
+  }
+  /**
+   * Handle unassignment of an agent
+   */
+  handleUnassigned() {
+    if (this.assignedAgentId === void 0) {
+      return;
+    }
+    const previousAgentId = this.assignedAgentId;
+    this.assignedAgentId = void 0;
+    if (this.status === "assigned" || this.status === "active") {
+      this.status = "queued";
+    }
+    this.emit("unassigned", { previousAgentId });
+    this.logger.debug("Support session unassigned:", this.conversationId);
+  }
+  /**
+   * Handle bot takeover
+   */
+  handleBotTakeover() {
+    if (this.botActive) {
+      return;
+    }
+    this.botActive = true;
+    this.emit("bot_takeover", {});
+    this.logger.debug("Bot took over support session:", this.conversationId);
+  }
+  /**
+   * Handle bot release
+   */
+  handleBotReleased() {
+    if (!this.botActive) {
+      return;
+    }
+    this.botActive = false;
+    this.emit("bot_released", {});
+    this.logger.debug("Bot released support session:", this.conversationId);
+  }
+  /**
+   * Handle session closed
+   */
+  handleClosed() {
+    if (this.status === "closed") {
+      return;
+    }
+    const previousStatus = this.status;
+    this.status = "closed";
+    this.emit("closed", { previousStatus });
+    this.logger.debug("Support session closed:", this.conversationId);
+  }
+  /**
+   * Handle session reopened
+   */
+  handleReopened() {
+    if (this.status !== "closed") {
+      return;
+    }
+    this.status = this.assignedAgentId ? "assigned" : "queued";
+    this.emit("reopened", {});
+    this.logger.debug("Support session reopened:", this.conversationId);
+  }
+  /**
+   * Send a message (delegates to Conversation)
+   */
+  sendMessage(content, messageType = "text", metadata) {
+    this.conversation.sendMessage(content, messageType, metadata);
+  }
+  /**
+   * Join the conversation (delegates to Conversation)
+   */
+  async join() {
+  }
+  /**
+   * Leave the conversation (delegates to Conversation)
+   */
+  async leave() {
+  }
+};
+
+// src/support/SupportManager.ts
+var SupportManager = class extends eventemitter3.EventEmitter {
+  constructor(getConversationHandler, debug = false) {
+    super();
+    this.sessions = /* @__PURE__ */ new Map();
+    this.getConversationHandler = getConversationHandler;
+    this.debug = debug;
+    this.logger = new Logger(debug);
+  }
+  /**
+   * Get or create a SupportSession for a conversation
+   * 
+   * Note: This assumes the conversation is a support conversation.
+   * The role is determined by the SDK user's context (not inferred).
+   * 
+   * @param conversationId - The conversation ID
+   * @param role - The role of the current user ('customer' or 'agent')
+   * @returns SupportSession instance
+   */
+  get(conversationId, role = "customer") {
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    let session = this.sessions.get(conversationId);
+    if (!session) {
+      const conversation = this.getConversationHandler(conversationId);
+      session = new SupportSession(conversationId, conversation, role, this.debug);
+      session.on("assigned", (data) => this.emit("assigned", { conversationId, ...data }));
+      session.on("unassigned", (data) => this.emit("unassigned", { conversationId, ...data }));
+      session.on("bot_takeover", () => this.emit("bot_takeover", { conversationId }));
+      session.on("bot_released", () => this.emit("bot_released", { conversationId }));
+      session.on("closed", (data) => this.emit("closed", { conversationId, ...data }));
+      session.on("reopened", () => this.emit("reopened", { conversationId }));
+      this.sessions.set(conversationId, session);
+      this.logger.debug("Created support session:", conversationId, role);
+    }
+    return session;
+  }
+  /**
+   * Check if a support session exists
+   */
+  has(conversationId) {
+    return this.sessions.has(conversationId);
+  }
+  /**
+   * Get a support session if it exists
+   */
+  getSession(conversationId) {
+    return this.sessions.get(conversationId);
+  }
+  /**
+   * Handle a support protocol event
+   */
+  handleSupportEvent(conversationId, eventType, payload) {
+    const session = this.sessions.get(conversationId);
+    if (!session) {
+      if (eventType === "assigned" && payload?.agent_id) {
+        this.logger.debug("Support event for unknown session, will be handled when session is created:", conversationId);
+      } else {
+        this.logger.warn("Support event for unknown session:", conversationId, eventType);
+      }
+      return;
+    }
+    switch (eventType) {
+      case "assigned":
+        if (payload?.agent_id && typeof payload.agent_id === "string") {
+          session.handleAssigned(payload.agent_id);
+        }
+        break;
+      case "unassigned":
+        session.handleUnassigned();
+        break;
+      case "bot_takeover":
+        session.handleBotTakeover();
+        break;
+      case "bot_released":
+        session.handleBotReleased();
+        break;
+      case "closed":
+        session.handleClosed();
+        break;
+      case "reopened":
+        session.handleReopened();
+        break;
+    }
+  }
+  /**
+   * Remove a support session
+   */
+  remove(conversationId) {
+    const session = this.sessions.get(conversationId);
+    if (session) {
+      this.sessions.delete(conversationId);
+      this.logger.debug("Removed support session:", conversationId);
+    }
+  }
+  /**
+   * Clear all support sessions
+   */
+  clear() {
+    this.sessions.clear();
+    this.logger.debug("Cleared all support sessions");
+  }
+};
+
+// src/core/ChatAfrika.ts
+var ChatAfrika = class extends eventemitter3.EventEmitter {
+  constructor(config) {
+    super();
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+    this.wsClient = null;
+    this.config = {
+      autoReconnect: true,
+      maxReconnectAttempts: 5,
+      reconnectDelay: 1e3,
+      debug: false,
+      apiUrl: "",
+      ...config
+    };
+    this.tokenManager = new TokenManager();
+    this.tokenManager.setToken(config.token);
+    this.logger = new Logger(this.config.debug);
+    this.wsClient = new WebSocketClient(this.config.wsUrl, {
+      autoReconnect: this.config.autoReconnect,
+      maxReconnectAttempts: this.config.maxReconnectAttempts,
+      reconnectDelay: this.config.reconnectDelay,
+      debug: this.config.debug
+    });
+    this.supportManager = new SupportManager(
+      (conversationId) => this.conversationManager.get(conversationId),
+      this.config.debug
+    );
+    this.conversationManager = new ConversationManager(
+      (message) => {
+        if (!this.wsClient) {
+          throw new Error("WebSocket client not initialized");
+        }
+        this.wsClient.send(message);
+      },
+      this.config.debug,
+      void 0,
+      // supportMessageHandler (set later)
+      (message) => {
+        if (!this.wsClient) {
+          throw new Error("WebSocket client not initialized");
+        }
+        this.wsClient.send(message);
+      }
+    );
+    this.presenceManager = new PresenceManager(this.config.debug);
+    this.presenceManager.on("presence", (event) => {
+      this.emit("presence", event);
+    });
+    this.setupWebSocketHandlers();
+  }
+  /**
+   * Set up WebSocket event handlers
+   */
+  setupWebSocketHandlers() {
+    if (!this.wsClient) {
+      return;
+    }
+    this.wsClient.on("connected", () => {
+      this.connectionState = "connected" /* CONNECTED */;
+      this.emit("connected");
+      this.emit("state", this.connectionState);
+      this.logger.debug("SDK connected");
+    });
+    this.wsClient.on("disconnected", (data) => {
+      this.connectionState = "disconnected" /* DISCONNECTED */;
+      this.emit("disconnected", data);
+      this.emit("state", this.connectionState);
+      this.logger.debug("SDK disconnected");
+    });
+    this.wsClient.on("reconnecting", (data) => {
+      this.connectionState = "reconnecting" /* RECONNECTING */;
+      this.emit("reconnecting", data);
+      this.emit("state", this.connectionState);
+      this.logger.debug("SDK reconnecting", data);
+    });
+    this.wsClient.on("message", (message) => {
+      this.emit("message", message);
+      this.conversationManager.routeIncomingMessage(message);
+      if (message.type === "presence") {
+        const presenceMsg = message;
+        if (presenceMsg.payload) {
+          this.presenceManager.handlePresence(
+            presenceMsg.payload.user_id,
+            presenceMsg.payload.state
+          );
+        }
+      }
+      if (message.type === "support") {
+        this.conversationManager.routeSupportMessage(message);
+      }
+      switch (message.type) {
+        case "joined":
+          this.emit("joined", message);
+          break;
+        case "message":
+          this.emit("message", message);
+          break;
+        case "typing":
+          this.emit("typing", message);
+          break;
+        case "receipt":
+          break;
+        case "support":
+          break;
+        case "presence":
+          break;
+        case "error":
+          this.emit("error", message);
+          break;
+      }
+    });
+    this.wsClient.on("error", (error) => {
+      this.connectionState = "error" /* ERROR */;
+      const errorMessage = error instanceof Error ? error.message : "";
+      const errorName = error instanceof Error ? error.name : "";
+      if (errorName === "TokenExpiredError" || errorMessage && errorMessage.includes("Token expired")) {
+        this.logger.error("Token expired:", errorMessage);
+        this.logger.warn("To reconnect, call sdk.updateToken(newToken) then sdk.connect()");
+      } else {
+        this.logger.error("SDK error:", error);
+      }
+      const errorToEmit = error instanceof Error ? error : new Error("WebSocket connection error");
+      this.emit("error", errorToEmit);
+      this.emit("state", this.connectionState);
+    });
+  }
+  /**
+   * Get the current connection state
+   */
+  getState() {
+    return this.connectionState;
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Connect to the ChatAfrika service
+   */
+  async connect() {
+    if (this.connectionState === "connected" /* CONNECTED */) {
+      this.logger.warn("Already connected");
+      return;
+    }
+    if (this.connectionState === "connecting" /* CONNECTING */) {
+      this.logger.warn("Connection already in progress");
+      return;
+    }
+    this.tokenManager.validateTokenPresence();
+    const token = this.tokenManager.getToken();
+    if (!token) {
+      throw new Error("Token is required for connection");
+    }
+    this.connectionState = "connecting" /* CONNECTING */;
+    this.emit("state", this.connectionState);
+    this.logger.debug("Connecting...");
+    try {
+      if (!this.wsClient) {
+        throw new Error("WebSocket client not initialized");
+      }
+      await this.wsClient.connect(token);
+    } catch (error) {
+      this.connectionState = "error" /* ERROR */;
+      this.emit("state", this.connectionState);
+      const connectionError = error instanceof Error ? error : new Error("Connection failed");
+      this.emit("error", connectionError);
+      throw connectionError;
+    }
+  }
+  /**
+   * Disconnect from the ChatAfrika service
+   */
+  async disconnect() {
+    if (this.connectionState === "disconnected" /* DISCONNECTED */) {
+      return;
+    }
+    this.logger.debug("Disconnecting...");
+    this.conversationManager.clear();
+    this.presenceManager.clear();
+    this.supportManager.clear();
+    if (this.wsClient) {
+      this.wsClient.disconnect();
+    }
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+    this.emit("disconnected");
+    this.emit("state", this.connectionState);
+  }
+  /**
+   * Check if the client is connected
+   */
+  isConnected() {
+    return this.connectionState === "connected" /* CONNECTED */ && this.wsClient?.isConnected() === true;
+  }
+  /**
+   * Update the authentication token
+   * Use this when your token expires and you need to refresh it
+   * After updating, call connect() to reconnect with the new token
+   */
+  updateToken(newToken) {
+    if (!newToken || newToken.length === 0) {
+      throw new Error("Token cannot be empty");
+    }
+    this.tokenManager.setToken(newToken);
+    this.logger.debug("Token updated");
+    if (this.isConnected()) {
+      this.logger.warn("Token updated while connected. Disconnecting to reconnect with new token...");
+      this.disconnect();
+    }
+  }
+  /**
+   * Get the conversations manager
+   * Exposes: sdk.conversations.get(id), sdk.conversations.join(id), etc.
+   */
+  get conversations() {
+    return {
+      get: (id) => this.conversationManager.get(id),
+      has: (id) => this.conversationManager.has(id),
+      join: (id) => this.conversationManager.join(id, (conversationId) => this.joinConversation(conversationId)),
+      leave: (id) => this.conversationManager.leave(id, (conversationId) => this.leaveConversation(conversationId))
+    };
+  }
+  /**
+   * Get the support manager
+   * Exposes: sdk.support.get(conversationId, role?)
+   */
+  get support() {
+    return {
+      get: (id, role = "customer") => this.supportManager.get(id, role),
+      has: (id) => this.supportManager.has(id)
+    };
+  }
+  /**
+   * Join a conversation room (internal method used by ConversationManager)
+   */
+  async joinConversation(conversationId) {
+    if (!this.isConnected()) {
+      throw new Error("Must be connected before joining a conversation");
+    }
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    if (!this.wsClient) {
+      throw new Error("WebSocket client not initialized");
+    }
+    const message = {
+      type: "join",
+      conversation_id: conversationId
+    };
+    try {
+      this.wsClient.send(message);
+      this.logger.debug("Join conversation sent:", conversationId);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to join conversation");
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+  /**
+   * Leave a conversation room (internal method used by ConversationManager)
+   */
+  async leaveConversation(conversationId) {
+    if (!this.isConnected()) {
+      throw new Error("Must be connected before leaving a conversation");
+    }
+    if (!conversationId || conversationId.length === 0) {
+      throw new Error("Conversation ID is required");
+    }
+    if (!this.wsClient) {
+      throw new Error("WebSocket client not initialized");
+    }
+    const message = {
+      type: "leave",
+      conversation_id: conversationId
+    };
+    try {
+      this.wsClient.send(message);
+      this.logger.debug("Leave conversation sent:", conversationId);
+    } catch (error) {
+      const sendError = error instanceof Error ? error : new Error("Failed to leave conversation");
+      this.emit("error", sendError);
+      throw sendError;
+    }
+  }
+  /**
+   * Rotate the authentication token
+   */
+  rotateToken(newToken) {
+    this.tokenManager.rotateToken(newToken);
+    this.logger.debug("Token rotated");
+    if (this.isConnected()) {
+      this.logger.warn("Token rotated while connected. Reconnect may be required.");
+    }
+  }
+  /**
+   * Get the token manager (for advanced use cases)
+   */
+  getTokenManager() {
+    return this.tokenManager;
+  }
+};
+
+// src/utils/retry.ts
+async function retry(fn, options = {}) {
+  const {
+    maxAttempts = 3,
+    delay = 1e3,
+    backoff = true,
+    onRetry
+  } = options;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxAttempts) {
+        const waitTime = backoff ? delay * Math.pow(2, attempt - 1) : delay;
+        onRetry?.(attempt, lastError);
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+      }
+    }
+  }
+  throw lastError ?? new Error("Retry failed");
+}
+
+// src/utils/guards.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isValidUrl(value) {
+  if (!isNonEmptyString(value)) {
+    return false;
+  }
+  try {
+    new URL(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isPositiveInteger(value) {
+  return isNumber(value) && Number.isInteger(value) && value > 0;
+}
+
+exports.ChatAfrika = ChatAfrika;
+exports.ConnectionState = ConnectionState;
+exports.Conversation = Conversation;
+exports.ConversationManager = ConversationManager;
+exports.Logger = Logger;
+exports.MessageFactory = MessageFactory;
+exports.MessageManager = MessageManager;
+exports.PresenceManager = PresenceManager;
+exports.ReceiptManager = ReceiptManager;
+exports.SupportManager = SupportManager;
+exports.SupportSession = SupportSession;
+exports.TokenManager = TokenManager;
+exports.TypingManager = TypingManager;
+exports.WebSocketClient = WebSocketClient;
+exports.isNonEmptyString = isNonEmptyString;
+exports.isNumber = isNumber;
+exports.isPositiveInteger = isPositiveInteger;
+exports.isValidUrl = isValidUrl;
+exports.retry = retry;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map