@tarunzyraclavis/zyra-twilio-wrapper 1.0.0 → 1.0.8

package/src/index.ts

@@ -1,510 +1,424 @@
 import axios from "axios";
 import { Device, Call } from "@twilio/voice-sdk";
-import { handleAxiosError } from '../utils/errorHandler';
+import { handleAxiosError } from "../utils/errorHandler";
 import {
-  AddParticipantPayload,
-  CallResponse,
-  Config,
-  GetConferencePayload,
-  GetConferenceResult,
-  GetParticipantsPayload,
-  GetParticipantsResult,
-  HoldAndAddResult,
-  HoldCallPayload,
-  HoldPayload,
-  RemoveParticipantPayload,
-  RemoveParticipantResult,
-  ResumeCallPayload,
-  TokenRequestPayload,
-  TokenResponse,
-  TwilioConference,
-  TwilioConferenceParticipant,
-} from '../types/interface';
-import { createSuccessResult, createErrorResult } from '../utils/helper'
+    AddParticipantPayload,
+    CallResponse,
+    Config,
+    GetConferencePayload,
+    GetConferenceResult,
+    GetParticipantsPayload,
+    GetParticipantsResult,
+    HoldAndAddResult,
+    HoldCallPayload,
+    HoldPayload,
+    RemoveParticipantPayload,
+    RemoveParticipantResult,
+    ResumeCallPayload,
+    TokenRequestPayload,
+    TokenResponse,
+    TwilioConference,
+    TwilioConferenceParticipant,
+} from "../types/interface";
+import { createSuccessResult, createErrorResult } from "../utils/helper";
 
 export default class ZyraTwilioWrapper {
-  private readonly serverUrl: string;
-  private readonly identity: string;
-  private device: Device | null = null;
-  private activeConnection: Call | null = null;
-  private isInitialized: boolean = false;
-  private isInitializing: boolean = false;
-  public activeCallSid: string | null = null;
-  public conferenceName: string;
-  public conferenceDetail: TwilioConference | null = null;
-  public participants: TwilioConferenceParticipant[] = [];
-  public waitUrl: string = "https://api.twilio.com/cowbell.mp3";
-
-  // Optional event handlers
-  public onReady?: () => void;
-  public onIncoming?: (conn: Call) => void;
-  public onDisconnect?: () => void;
-  public onError?: (error: Error) => void;
-  public onConnect?: (conn: Call) => void;
-  public onMissedCall?: () => void;
-  public onAnswerOutGoing?: (conn: Call) => void;
-
-  constructor(configObj: Config) {
-    this.serverUrl = configObj.serverUrl;
-    this.identity = configObj.identity;
-    this.waitUrl = configObj.waitUrl || this.waitUrl;
-    this.conferenceName = `conf_${this.identity}`;
-  }
-
-  // /**
-  //  * Initialize the Twilio device and get token
-  //  */
+    private readonly serverUrl: string;
+    private readonly identity: string;
+    private readonly sdkToken: string;
+
+    private device: Device | null = null;
+    private activeConnection: Call | null = null;
+
+    private isInitialized = false;
+    private isInitializing = false;
+    private isAuthenticated = false;
+
+    private axiosInstance = axios.create();
+
+    public activeCallSid: string | null = null;
+    public conferenceName: string;
+    public conferenceDetail: TwilioConference | null = null;
+    public participants: TwilioConferenceParticipant[] = [];
+    public waitUrl = "https://api.twilio.com/cowbell.mp3";
+
+    // Optional event handlers
+    public onReady?: () => void;
+    public onIncoming?: (conn: Call) => void;
+    public onDisconnect?: () => void;
+    public onError?: (error: Error) => void;
+    public onConnect?: (conn: Call) => void;
+    public onMissedCall?: () => void;
+
+    constructor(config: Config) {
+        this.serverUrl = config.serverUrl;
+        this.identity = config.identity;
+        this.sdkToken = config.sdkToken;
+        this.waitUrl = config.waitUrl || this.waitUrl;
+
+        // safer conference name
+        this.conferenceName = `conf_${this.identity}_${Date.now()}`;
+    }
+
+    /* ------------------------------------------------------------------ */
+    /* AUTH                                                               */
+    /* ------------------------------------------------------------------ */
+
+    private setupAxiosAuth(token: string) {
+        this.axiosInstance.defaults.headers.common["Authorization"] = `Bearer ${token}`;
+    }
+
+    private ensureAuthenticated() {
+        if (!this.isAuthenticated) {
+            throw new Error("SDK not authenticated.");
+        }
+    }
+
+    public async verifySDKToken(): Promise<boolean> {
+        if (!this.sdkToken) {
+            throw new Error("SDK token not provided");
+        }
+
+        try {
+            const res = await this.axiosInstance.post(
+                `${this.serverUrl}/voipSdk.verifySdkToken`,
+                {},
+                { headers: { Authorization: `Bearer ${this.sdkToken}` } }
+            );
+
+            console.log("verifySDKToken :", res.data.result.data.verified);
+
+            if (res?.data?.result?.data?.verified) {
+                this.isAuthenticated = true;
+                this.setupAxiosAuth(this.sdkToken);
+                console.info("[verifySDKToken] SDK token verified");
+                return true;
+            }
+
+            throw new Error("Invalid SDK token");
+        } catch (error) {
+            this.isAuthenticated = false;
+            throw new Error("SDK authentication failed");
+        }
+    }
+
+    // /**
+    //  * Initialize the Twilio device and get token
+    //  */
     /**
    * Initialize the SDK. Can only be called once.
    * 
    * @throws {Error} If already initialized or initialization fails
    * @returns Promise that resolves when initialization is complete
    */
-public async init(): Promise<void> {
-  if (this.isInitialized) {
-    throw new Error(
-      "SDK is already initialized. Call destroy() first to reinitialize."
-    );
-  }
-
-  if (this.isInitializing) {
-    throw new Error("SDK initialization is already in progress");
-  }
-
-  this.isInitializing = true;
-
-  try {
-    // Validate configuration
-    if (!this.serverUrl) {
-      throw new Error("serverUrl is required");
-    }
-    if (!this.identity) {
-      throw new Error("identity is required");
-    }
+    public async init(): Promise<void> {
+        this.ensureAuthenticated();
 
-    // Generate token and create Device
-    const token = await this.generateToken();
-    this.device = new Device(token, { logLevel: 3 });
-
-    // Setup event handlers
-    this.setupDeviceEventHandlers();
-
-    // Register the device
-    await this.device.register();
-
-    this.isInitialized = true;
-    console.info("[init] Device registration completed");
-  } catch (error: unknown) {
-    handleAxiosError(error, this.onError, "Failed to fetch token");
-    throw error;
-  } finally {
-    // Reset initializing flag even if init fails
-    this.isInitializing = false;
-  }
-}
+        if (this.isInitialized) {
+            throw new Error("SDK already initialized");
+        }
 
-  // Private methods for get token for initialize the device
-  private async generateToken(): Promise<string> {
-    try {
-      const payload: TokenRequestPayload = {
-          identity: this.identity,
-          ttl: 3600,
-          incomingAllow: true,
-      };
+        if (this.isInitializing) {
+            throw new Error("SDK initialization already in progress");
+        }
 
-      const res = await axios.post<TokenResponse>(`${this.serverUrl}/voipSdk.generateToken`, payload);
+        this.isInitializing = true;
 
-      const token = res.data.result.data.token;
+        try {
+            const token = await this.generateToken();
+            this.device = new Device(token, { logLevel: "info" });
 
-      if (!token) {
-        throw new Error("Token not found in server response");
-      }
+            this.setupDeviceEventHandlers();
+            await this.device.register();
 
-      return token;
-    } catch (error : unknown) {
-      handleAxiosError(error, this.onError, "Failed to generate Twilio token");
-      throw error;
+            this.isInitialized = true;
+            console.info("[init] Device registered");
+        } finally {
+            this.isInitializing = false;
+        }
+    }
+    // Private methods for get token for initialize the device
+
+    private async generateToken(): Promise<string> {
+        try {
+            const payload: TokenRequestPayload = {
+                json: {
+                    identity: this.identity,
+                    ttl: 3600,
+                    incomingAllow: true,
+                },
+            };
+
+            console.log("Generating token with payload:", payload);
+
+            const res = await this.axiosInstance.post<TokenResponse>(
+                `https://nextdev.zyratalk.com/api/trpc/voipSdk.generateToken`,
+                payload
+            );  // This will be changed to this.serverUrl in production
+
+            const token = res?.data?.result?.data?.token;
+            if (!token) throw new Error("Token missing");
+
+            return token;
+        } catch (error) {
+            handleAxiosError(error, this.onError, "Token generation failed");
+            throw error;
+        }
     }
-  }
-
-  // Private methods for handling the event for device
-  private setupDeviceEventHandlers(): void {
-  if (!this.device) return;
-
-  this.device.on("registered", () => {
-    console.info("[Device] Registered");
-    this.onReady?.();
-  });
-
-  this.device.on("incoming", (conn: Call) => {
-    console.info("[Device] Incoming call detected");
-    conn.on("cancel", () => {
-      console.warn("[Device] Caller hung up before answer");
-      this.activeConnection = null;
-      this.onMissedCall?.();
-    });
-    conn.on("reject", () => {
-      console.warn("[Device] Call rejected");
-      this.activeConnection = null;
-    });
-    conn.on("accept", () => console.info("[Device] Call accepted"));
-    this.activeConnection = conn;
-    this.onIncoming?.(conn);
-  });
-
-  this.device.on("disconnect", () => {
-    console.info("[Device] Call disconnected");
-    this.activeConnection = null;
-    this.onDisconnect?.();
-  });
-
-  this.device.on("connect", (conn: Call) => {
-    console.info("[Device] Call connected");
-    this.activeConnection = conn;
-    this.onConnect?.(conn);
-  });
-
-  this.device.on("error", (error: Error) => {
-    handleAxiosError(error, this.onError, "Device encountered an error");
-  });
-}
 
-  /**
-   * Check if SDK is initialized
-   */
-  get initialized(): boolean {
-    return this.isInitialized;
-  }
-  
-  /**
-   * Destroy the SDK instance and clean up resources
-   */
-  public destroy(): void {
-  if (this.device) {
-    // Remove all event listeners
-    this.device.removeAllListeners();
-
-    // Optionally, explicitly handle any final error events
-    this.device.on("error", (error: Error) => {
-      handleAxiosError(error, this.onError, "Device encountered an error during destroy");
-    });
-
-    // When Token expires then get new and update with twilio
-    this.device.on('tokenWillExpire', async () => {
-      const token = await this.generateToken();
-      this.device?.updateToken(token);
-    });
-    // Shutdown device
-    this.device.destroy();
-    this.device = null;
-  }
-
-  // Reset state flags
-  this.isInitialized = false;
-  this.isInitializing = false;
-  this.activeConnection = null;
-
-  console.info("[destroy] Device destroyed and SDK state reset");
-}
+    private setupDeviceEventHandlers() {
+        if (!this.device) return;
 
+        this.device.on("registered", () => this.onReady?.());
 
-  /**
-   * Make an outgoing call or add participant to an existing call
-   */
-  public async makeCall(to: string): Promise<CallResponse<Call>> {
-    if (!this.device) {
-      return createErrorResult("Device not initialized");
-    }
+        this.device.on("incoming", (conn: Call) => {
+            this.activeConnection = conn;
 
-    if (!to) {
-      console.warn("[makeCall] 'to' parameter is required");
-      return createErrorResult("[makeCall] 'to' parameter is required");
-    }
+            conn.on("cancel", () => {
+                this.activeConnection = null;
+                this.onMissedCall?.();
+            });
 
-    if (!this.activeConnection) {
-      try {
-        const connection = await this.device.connect({
-          params: { To: to, conferenceName: this.conferenceName },
-        });
+            conn.on("reject", () => (this.activeConnection = null));
+            conn.on("accept", () => console.info("[Device] Call accepted"));
 
-        this.activeConnection = connection;
+            this.onIncoming?.(conn);
+        });
 
-        connection.on("accept", async (conn: Call) => {
-          this.activeCallSid = connection?.parameters?.CallSid ?? null;
-          console.info(`[makeCall] Call accepted. Call SID: ${this.activeCallSid}`);
-          this.onAnswerOutGoing?.(conn);
-          await this.getConferenceId();
+        this.device.on("connect", (conn: Call) => {
+            this.activeConnection = conn;
+            this.onConnect?.(conn);
         });
 
-        connection.on("error", (error: Error) => {
-          console.error("[makeCall] Connection error:", error.message);
-          this.onError?.(error);
+        this.device.on("disconnect", () => {
+            this.activeConnection = null;
+            this.onDisconnect?.();
         });
 
-        connection.on("disconnect", () => {
-          console.info("[makeCall] Call disconnected.");
-          this.activeConnection = null;
-          this.onDisconnect?.();
+        this.device.on("error", (error: Error) => {
+            handleAxiosError(error, this.onError, "Device error");
         });
 
-        console.info(`[makeCall] Outgoing call initiated to: ${to}`);
-        return createSuccessResult(`[makeCall] Outgoing call initiated to: ${to}`, connection);
-      } catch (error: unknown) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error("[makeCall] Failed to initiate call:", err.message);
-        this.onError?.(err);
-        return createErrorResult(`[makeCall] Failed to initiate call: ${err.message}`);
-      }
-    } else {
-      try {
-        console.info("[makeCall] Active call found. Holding and adding new participant...");
-        await this.holdAndAddParticipant(this.activeConnection.parameters.CallSid, to);
-        return createSuccessResult(`[makeCall] Outgoing participant  ${to} added`, this.activeConnection);
-      } catch (error: unknown) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error("[makeCall] Failed to add participant:", err.message);
-        this.onError?.(err);
-        return createErrorResult(`[makeCall] Failed to add participant: ${err.message}`);
-      }
+        this.device.on("tokenWillExpire", async () => {
+            const token = await this.generateToken();
+            this.device?.updateToken(token);
+        });
     }
-  }
 
-  /**
-   * Accept incoming call
+    /* ------------------------------------------------------------------ */
+  /* CALL CONTROL                                                        */
+  /* ------------------------------------------------------------------ */
+
+    /**
+   * Make an outgoing call or add participant to an existing call
    */
-  public acceptCall(): CallResponse<Call> {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device
-        ? "Device not initialized."
-        : "No active call to accept.";
-      console.warn(`[acceptCall] ${msg}`);
-      return createErrorResult(`[acceptCall] ${msg}`);
-    }
 
-    try {
-      this.activeConnection.accept();
-      console.info("[acceptCall] Call accepted successfully.");
-      return createSuccessResult("Call accepted successfully.", this.activeConnection);
-    } catch (error: unknown) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[acceptCall] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`[acceptCall] Failed: ${err.message}`);
+    public async makeCall(to: string): Promise<CallResponse<Call>> {
+        this.ensureAuthenticated();
+
+        if (!this.device) return createErrorResult("Device not initialized");
+        if (!to) return createErrorResult("Destination required");
+
+        if (!this.activeConnection) {
+            const conn = await this.device.connect({
+                params: { To: to, conferenceName: this.conferenceName },
+            });
+
+            this.activeConnection = conn;
+
+            conn.on("accept", async () => {
+                this.activeCallSid = conn.parameters?.CallSid ?? null;
+                await this.getConferenceId();
+            });
+
+            return createSuccessResult("Call started", conn);
+        }
+
+        await this.holdAndAddParticipant(
+            this.activeConnection.parameters.CallSid,
+            to
+        );
+
+        return createSuccessResult("Participant added", this.activeConnection);
     }
-  }
 
-  /**
-   * Hang up active call
-   */
-  public hangup(): CallResponse<Call | null> {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device
-        ? "Device not initialized."
-        : "No active call to hang up.";
-      console.warn(`[hangup] ${msg}`);
-      return createErrorResult(`[hangup] ${msg}`);
+    /**
+  * Accept incoming call
+  */
+
+    public acceptCall(): CallResponse<Call> {
+        if (!this.activeConnection) {
+            return createErrorResult("No incoming call");
+        }
+
+        this.activeConnection.accept();
+        return createSuccessResult("Call accepted", this.activeConnection);
     }
 
-    try {
-      this.device.disconnectAll();
-      this.activeConnection = null;
-      console.info("[hangup] Call hung up successfully.");
-      return createSuccessResult("Call hung up successfully.", this.activeConnection);
-    } catch (error: unknown) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[hangup] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to hang up: ${err.message}`);
+    /**
+  * Hang up active call
+  */
+
+    public hangup(): CallResponse<null> {
+        if (!this.device) return createErrorResult("Device not initialized");
+
+        this.device.disconnectAll();
+        this.activeConnection = null;
+
+        return createSuccessResult("Call ended", null);
     }
-  }
 
-  /**
+    /**
    * Reject incoming call
    */
-  public rejectCall(): CallResponse<Call | null> {
-    if (!this.device || !this.activeConnection) {
-      const msg = !this.device
-        ? "Device not initialized."
-        : "No active call to reject.";
-      console.warn(`[rejectCall] ${msg}`);
-      return createErrorResult(`[rejectCall] ${msg}`);
-    }
 
-    try {
-      this.activeConnection.reject();
-      this.activeConnection = null;
-      console.info("[rejectCall] Call rejected successfully.");
-      return createSuccessResult("[rejectCall] Call rejected successfully.", this.activeConnection);
-    } catch (error: unknown) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[rejectCall] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to reject call: ${err.message}`);
+    public rejectCall(): CallResponse<null> {
+        if (!this.activeConnection) return createErrorResult("No call to reject");
+
+        this.activeConnection.reject();
+        this.activeConnection = null;
+
+        return createSuccessResult("Call rejected", null);
     }
-  }
 
-  /**
+    /**
    * Toggle mute/unmute
    */
-  public toggleMute(mute: boolean): CallResponse<Call> {
-    if (!this.activeConnection) {
-      console.warn("[toggleMute] No active call to mute/unmute.");
-      return createErrorResult("[toggleMute] No active call to mute/unmute.");
-    }
 
-    try {
-      this.activeConnection.mute(mute);
-      console.info(`[toggleMute] Call ${mute ? "muted" : "unmuted"} successfully.`);
-      return createSuccessResult(`Call ${mute ? "muted" : "unmuted"} successfully.`, this.activeConnection);
-    } catch (error: unknown) {
-      const err = error instanceof Error ? error : new Error(String(error));
-      console.error("[toggleMute] Failed:", err.message);
-      this.onError?.(err);
-      return createErrorResult(`Failed to toggle mute: ${err.message}`);
+    public toggleMute(mute: boolean): CallResponse<Call> {
+        if (!this.activeConnection) return createErrorResult("No active call");
+
+        this.activeConnection.mute(mute);
+        return createSuccessResult(`Mute ${mute}`, this.activeConnection);
     }
-  }
 
-  /**
+    /* ------------------------------------------------------------------ */
+    /* CONFERENCE API                                                      */
+    /* ------------------------------------------------------------------ */
+
+    /**
    * Hold a call
    */
-  public async hold(callSid: string): Promise<CallResponse<Call>> {
-    if (!this.activeConnection) return createErrorResult("No active call to hold.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-
-    try {
-      const payload: HoldCallPayload = { callSid, conferenceName: this.conferenceName, waitUrl: this.waitUrl };
-      await axios.post(`${this.serverUrl}/outgoingCall.hold`, payload);
-      console.info("[hold] Call held successfully.");
-      return createSuccessResult("Call held successfully.", this.activeConnection);
-
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to hold call");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to hold call: ${errMessage}`);
+    public async hold(callSid: string) {
+        this.ensureAuthenticated();
+
+        const payload: HoldCallPayload = {
+            callSid,
+            conferenceName: this.conferenceName,
+            waitUrl: this.waitUrl,
+        };
+
+        await this.axiosInstance.post(`${this.serverUrl}/outgoingCall.hold`, payload);
+        return createSuccessResult("Call held", this.activeConnection);
     }
-  }
 
-  /**
+    /**
    * Resume a held call
    */
-  public async resume(callSid: string): Promise<CallResponse<Call>> {
-    if (!this.activeConnection) return createErrorResult("No active call to resume.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-
-    try {
-      const payload: ResumeCallPayload = { callSid, conferenceName: this.conferenceName };
-      await axios.post(`${this.serverUrl}/outgoingCall.unhold`, payload);
-      console.info("[resume] Call resumed successfully.");
-      return createSuccessResult("Call resumed successfully.", this.activeConnection);
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to resume call");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to resume call: ${errMessage}`);
-    }
-  }
 
-  /**
-   * Hold active call and add a new participant
-   */
-  public async holdAndAddParticipant(callSid: string, newParticipantNo: string): Promise<HoldAndAddResult | CallResponse> {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    if (!newParticipantNo) return createErrorResult("Please provide participant number.");
-
-    try {
-      const holdPayload: HoldPayload = { conferenceName: this.conferenceName, callSid, waitUrl: this.waitUrl };
-      const holdRes = await axios.post(`${this.serverUrl}/outgoingCall.hold`, holdPayload);
-
-      const addPayload: AddParticipantPayload = { conferenceName: this.conferenceName, newParticipantNo };
-      const addRes = await axios.post(`${this.serverUrl}/outgoingCall.addNewCallee`, addPayload);
-
-      console.info("[holdAndAddParticipant] Call held and participant added successfully.");
-      return {
-        message: "Call held and participant added successfully.",
-        status: true,
-        holdResponse: holdRes.data,
-        addParticipantResponse: addRes.data,
-      };
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to hold and add participant");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to hold/add participant: ${errMessage}`);
+    public async resume(callSid: string) {
+        this.ensureAuthenticated();
+
+        const payload: ResumeCallPayload = {
+            callSid,
+            conferenceName: this.conferenceName,
+        };
+
+        await this.axiosInstance.post(
+            `${this.serverUrl}/outgoingCall.unhold`,
+            payload
+        );
+
+        return createSuccessResult("Call resumed", this.activeConnection);
     }
-  }
 
-  /**
-   * Fetch conference details
-   */
-  public async getConferenceId(): Promise<GetConferenceResult | CallResponse<TwilioConference>> {
-    if (!this.activeConnection) return createErrorResult("No active call.");
+    /**
+  * Hold active call and add a new participant
+  */
 
-    const payload: GetConferencePayload = { conferenceName: this.conferenceName };
+    public async holdAndAddParticipant(callSid: string, number: string) {
+        this.ensureAuthenticated();
 
-    try {
-      const res = await axios.post(`${this.serverUrl}/outgoingCall.getConferenceId`, payload);
+        await this.hold(callSid);
 
-      if (res?.data?.result?.data) {
-        const confDetails: TwilioConference = {
-          conferenceSid: res.data.result.data.conferenceSid,
-          conferences: res.data.result.data.conferences,
+        const payload: AddParticipantPayload = {
+            conferenceName: this.conferenceName,
+            newParticipantNo: number,
         };
-        this.conferenceDetail = confDetails;
-        console.info("[getConferenceId] Conference details fetched successfully.");
-        return createSuccessResult("Call resumed successfully.", confDetails);
-      }
-
-      console.warn("[getConferenceId] No conference data returned from server.");
-      return { message: "No conference data returned.", status: false };
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to get conference ID");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to get conference ID: ${errMessage}`);
+
+        const res = await this.axiosInstance.post(
+            `${this.serverUrl}/outgoingCall.addNewCallee`,
+            payload
+        );
+
+        return createSuccessResult("Participant added", res.data);
     }
-  }
 
-  /**
+    /**
+        * Fetch conference details
+   */
+
+    public async getConferenceId() {
+        this.ensureAuthenticated();
+
+        const payload: GetConferencePayload = {
+            conferenceName: this.conferenceName,
+        };
+
+        const res = await this.axiosInstance.post(
+            `${this.serverUrl}/outgoingCall.getConferenceId`,
+            payload
+        );
+
+        this.conferenceDetail = res?.data?.result?.data ?? null;
+        return createSuccessResult("Conference fetched", this.conferenceDetail);
+    }
+    /**
    * Get participants of a conference
    */
-  public async getParticipants(conferenceSid: string): Promise<GetParticipantsResult | CallResponse<TwilioConferenceParticipant[]>> {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!conferenceSid) return createErrorResult("Please provide conferenceSid.");
-
-    try {
-      const payload: GetParticipantsPayload = { conferenceSid };
-      const res = await axios.post(`${this.serverUrl}/outgoingCall.getParticipants`, payload);
-
-      if (res?.data?.result?.data?.participants) {
-        this.participants = res.data.result.data.participants;
-        console.info("[getParticipants] Participants fetched successfully.");
-        return createSuccessResult("Participants fetched successfully.", this.participants);
-      }
-
-      console.warn("[getParticipants] No participants returned from server.");
-      return { message: "No participants returned.", status: false };
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to get participants");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to get participants: ${errMessage}`);
+    public async getParticipants(conferenceSid: string) {
+        this.ensureAuthenticated();
+
+        const payload: GetParticipantsPayload = { conferenceSid };
+
+        const res = await this.axiosInstance.post(
+            `${this.serverUrl}/outgoingCall.getParticipants`,
+            payload
+        );
+
+        this.participants = res?.data?.result?.data?.participants ?? [];
+        return createSuccessResult("Participants fetched", this.participants);
     }
-  }
 
-  /**
+ /**
    * Remove a participant from a conference
-   */
-  public async removeParticipant(conferenceSid: string, callSid: string): Promise<RemoveParticipantResult | CallResponse> {
-    if (!this.activeConnection) return createErrorResult("No active call.");
-    if (!callSid) return createErrorResult("Please provide callSid.");
-    if (!conferenceSid) return createErrorResult("Please provide conferenceSid.");
-
-    try {
-      const payload: RemoveParticipantPayload = { callSid, conferenceSid };
-      const res = await axios.post(`${this.serverUrl}/outgoingCall.removeParticipant`, payload);
-      console.info("[removeParticipant] Participant removed successfully.");
-      return createSuccessResult("Participant removed successfully.", res.data);
-    } catch (error: unknown) {
-      handleAxiosError(error, this.onError, "Failed to remove participant");
-      const errMessage = error instanceof Error ? error.message : String(error);
-      return createErrorResult(`Failed to remove participant: ${errMessage}`);
+   */    public async removeParticipant(conferenceSid: string, callSid: string) {
+        this.ensureAuthenticated();
+
+        const payload: RemoveParticipantPayload = { conferenceSid, callSid };
+
+        const res = await this.axiosInstance.post(
+            `${this.serverUrl}/outgoingCall.removeParticipant`,
+            payload
+        );
+
+        return createSuccessResult("Participant removed", res.data);
     }
-  }
-}
+
+    /* ------------------------------------------------------------------ */
+    /* CLEANUP                                                            */
+    /* ------------------------------------------------------------------ */
+
+    public destroy() {
+        if (this.device) {
+            this.device.removeAllListeners();
+            this.device.destroy();
+            this.device = null;
+        }
+
+        this.activeConnection = null;
+        this.isInitialized = false;
+        this.isInitializing = false;
+        this.isAuthenticated = false;
+    }
+}