@anganyai/voice-sdk 0.0.1 → 0.0.4

package/dist/index.js

@@ -3459,8 +3459,18 @@ var AuthManager = class extends EventEmitter {
   }
   /**
    * Get ephemeral credentials for WebRTC connections
+   *
+   * Returns cached credentials if available and valid, otherwise fetches new ones.
+   * This supports both:
+   * - Externally-provided credentials (via setEphemeralCredentials)
+   * - SDK-managed credentials (fetched using access token)
    */
   async getEphemeralCredentials() {
+    const cached = this.credentialManager.getCachedEphemeralCredentials();
+    if (cached) {
+      this.logger.debug("Using cached ephemeral credentials");
+      return cached;
+    }
     const accessToken = await this.getAccessToken();
     if (!accessToken) {
       throw new AuthenticationError("No access token available for ephemeral credentials");
@@ -16236,6 +16246,26 @@ var UserAgent = class _UserAgent {
   }
 };
 
+// src/utils/platform.ts
+function detectPlatform() {
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return "react-native";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+function isReactNative() {
+  return detectPlatform() === "react-native";
+}
+function isBrowser() {
+  return detectPlatform() === "browser";
+}
+function hasAudioContext() {
+  return typeof AudioContext !== "undefined" || typeof globalThis.webkitAudioContext !== "undefined";
+}
+
 // src/services/SipManager.ts
 var SipManager = class extends EventEmitter {
   constructor() {
@@ -16534,7 +16564,9 @@ var SipManager = class extends EventEmitter {
     }
   }
   setupAudioHandling(session) {
-    this.logger.debug("Setting up audio handling using SIP.js streams");
+    this.logger.debug("Setting up audio handling using SIP.js streams", {
+      platform: isReactNative() ? "react-native" : "browser"
+    });
     const sessionDescriptionHandler = session.sessionDescriptionHandler;
     if (sessionDescriptionHandler) {
       this.logger.debug("Session description handler found");
@@ -16542,18 +16574,22 @@ var SipManager = class extends EventEmitter {
       if (remoteStream) {
         this.logger.info("Remote media stream available");
         this.remoteStream = remoteStream;
-        this.createAudioElement();
-        if (this.audioElement) {
-          this.audioElement.srcObject = remoteStream;
-          this.audioElement.play().catch((error) => {
-            this.logger.warn("Autoplay prevented, enabling controls for user interaction", {
-              error
+        if (isReactNative()) {
+          this.logger.info("React Native: Remote audio will be played automatically by WebRTC");
+        } else {
+          this.createAudioElement();
+          if (this.audioElement) {
+            this.audioElement.srcObject = remoteStream;
+            this.audioElement.play().catch((error) => {
+              this.logger.warn("Autoplay prevented, enabling controls for user interaction", {
+                error
+              });
+              if (this.audioElement) {
+                this.audioElement.controls = true;
+                this.audioElement.style.display = "block";
+              }
             });
-            if (this.audioElement) {
-              this.audioElement.controls = true;
-              this.audioElement.style.display = "block";
-            }
-          });
+          }
         }
         this.startAudioMonitoring();
       } else {
@@ -16572,16 +16608,22 @@ var SipManager = class extends EventEmitter {
           if (event.streams[0]) {
             this.remoteStream = event.streams[0];
             this.logger.info("Remote audio stream received via ontrack fallback");
-            this.createAudioElement();
-            if (this.audioElement && this.remoteStream) {
-              this.audioElement.srcObject = this.remoteStream;
-              this.audioElement.play().catch((error) => {
-                this.logger.warn("Failed to auto-play remote audio", { error });
-                if (this.audioElement) {
-                  this.audioElement.controls = true;
-                  this.audioElement.style.display = "block";
-                }
-              });
+            if (isReactNative()) {
+              this.logger.info(
+                "React Native: Remote audio from ontrack will be played automatically"
+              );
+            } else {
+              this.createAudioElement();
+              if (this.audioElement && this.remoteStream) {
+                this.audioElement.srcObject = this.remoteStream;
+                this.audioElement.play().catch((error) => {
+                  this.logger.warn("Failed to auto-play remote audio", { error });
+                  if (this.audioElement) {
+                    this.audioElement.controls = true;
+                    this.audioElement.style.display = "block";
+                  }
+                });
+              }
             }
             this.startAudioMonitoring();
           }
@@ -16610,8 +16652,19 @@ var SipManager = class extends EventEmitter {
   }
   /**
    * Create and configure the audio element for remote audio playback
+   * In React Native, audio is handled differently through WebRTC streams
    */
   createAudioElement() {
+    if (isReactNative()) {
+      this.logger.debug(
+        "React Native detected - skipping audio element creation (handled by WebRTC)"
+      );
+      return;
+    }
+    if (!isBrowser()) {
+      this.logger.debug("Non-browser environment - skipping audio element creation");
+      return;
+    }
     if (this.audioElement) {
       return;
     }
@@ -16670,6 +16723,22 @@ var SipManager = class extends EventEmitter {
     if (!this.localStream || this.audioMonitorInterval) {
       return;
     }
+    if (isReactNative() || !hasAudioContext()) {
+      this.logger.debug("AudioContext not available - using simulated audio monitoring");
+      this.audioMonitorInterval = setInterval(() => {
+        if (this.state === "incall" && this.localStream) {
+          const audioTrack = this.localStream.getAudioTracks()[0];
+          if (audioTrack && audioTrack.enabled) {
+            const simulatedLevel = 0.2 + Math.random() * 0.5;
+            this.emit("audioLevel", simulatedLevel);
+          } else {
+            this.emit("audioLevel", 0);
+          }
+        }
+      }, 100);
+      this.logger.debug("Simulated audio monitoring started");
+      return;
+    }
     try {
       this.audioContext = new AudioContext();
       const source = this.audioContext.createMediaStreamSource(this.localStream);
@@ -16701,9 +16770,11 @@ var SipManager = class extends EventEmitter {
     delete this.audioAnalyser;
   }
   cleanupAudioResources() {
-    this.logger.debug("\u{1F9F9} Performing complete audio resource cleanup...");
+    this.logger.debug("\u{1F9F9} Performing complete audio resource cleanup...", {
+      platform: isReactNative() ? "react-native" : "browser"
+    });
     this.stopAudioMonitoring();
-    if (this.audioElement) {
+    if (this.audioElement && isBrowser()) {
       this.logger.debug("\u{1F9F9} Cleaning up audio element...");
       if (this.audioElement.srcObject) {
         const tracks = this.audioElement.srcObject.getTracks();
@@ -16864,7 +16935,7 @@ var TranscriptionService = class extends EventEmitter {
    * Connect to SSE endpoint with token refresh support
    */
   async connectToSSE(accessToken, isRetry = false) {
-    const sseUrl = `${this.apiUrl}/api/v1/events?event_types=transcription`;
+    const sseUrl = `${this.apiUrl}/api/v1/events?event_types=transcription,call_event`;
     this.logger.debug("Connecting to SSE endpoint", { url: sseUrl, isRetry });
     const response = await fetch(sseUrl, {
       method: "GET",
@@ -16994,13 +17065,36 @@ var TranscriptionService = class extends EventEmitter {
     }
   }
   handleMessage(data) {
-    this.logger.debug("Handling SSE message", { data });
-    if (data.type === "transcription" && data.text) {
-      if (data.call_id && !this.currentCallId) {
-        this.currentCallId = data.call_id;
-        this.emit("callId", data.call_id);
-        this.logger.info("Captured call ID from transcription", { callId: data.call_id });
+    this.logger.debug("Handling SSE message", { type: data.type, data });
+    if (data.call_id && !this.currentCallId) {
+      this.currentCallId = data.call_id;
+      this.emit("callId", data.call_id);
+      this.logger.info("Captured call ID", { callId: data.call_id, messageType: data.type });
+    }
+    if (data.type === "connection" || data.type === "welcome" || data.type === "connected") {
+      this.logger.info("Received connection event", {
+        type: data.type,
+        status: data.status
+      });
+      if (data.type === "connected" || data.status === "connected") {
+        this.emit("connected");
+      }
+    } else if (data.type === "call_started") {
+      this.logger.info("Received call_started event", {
+        callId: data.call_id,
+        organizationId: data.organization_id
+      });
+      if (data.call_id) {
+        this.emit("callStarted", data.call_id);
       }
+    } else if (data.type === "call_ended") {
+      this.logger.info("Received call_ended event", {
+        callId: data.call_id
+      });
+      if (data.call_id) {
+        this.emit("callEnded", data.call_id);
+      }
+    } else if (data.type === "transcription" && data.text) {
       const event = {
         speaker: data.direction === "agent" ? "agent" : "user",
         text: data.text.trim(),
@@ -17008,6 +17102,9 @@ var TranscriptionService = class extends EventEmitter {
         isFinal: true,
         // Assume final for now
         callId: data.call_id,
+        humanTurnId: data.human_turn_id ?? void 0,
+        agentTurnId: data.agent_turn_id ?? void 0,
+        speakerId: data.speaker_id ?? void 0,
         metadata: data
       };
       this.logger.debug("Emitting transcription event", { event });
@@ -17079,7 +17176,8 @@ var ApiService = class {
     this.logger.debug("Sending voice text", {
       callId: options.callId,
       textLength: options.text.length,
-      interrupt: options.interrupt,
+      interruptsConversation: options.interruptsConversation,
+      queueWhenSpeaking: options.queueWhenSpeaking,
       muteAgent: options.muteAgent
     });
     try {
@@ -17093,10 +17191,10 @@ var ApiService = class {
           },
           body: JSON.stringify({
             text: options.text,
-            interrupts_conversation: options.interrupt !== false,
-            // Default true
-            queue_when_speaking: false,
-            mute_agent: options.muteAgent
+            interrupts_conversation: options.interruptsConversation ?? true,
+            queue_when_speaking: options.queueWhenSpeaking ?? false,
+            mute_agent: options.muteAgent ?? null,
+            voice_settings: options.voiceSettings ?? null
           })
         }
       );
@@ -17182,11 +17280,103 @@ var ApiService = class {
       throw new NetworkError("Failed to set agent mute status", { cause: error });
     }
   }
+  /**
+   * Mute a call (POST /calls/{call_id}/mute)
+   */
+  async muteCall(callId, accessToken) {
+    this.logger.debug("Muting call", { callId });
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/conversations/calls/${callId}/mute`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+      if (response.status === 401) {
+        throw new AuthenticationError("Authentication failed");
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new NetworkError(
+          `Failed to mute call: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      this.logger.info("Call muted successfully", { callId });
+    } catch (error) {
+      if (error instanceof AuthenticationError || error instanceof NetworkError) {
+        throw error;
+      }
+      this.logger.error("Failed to mute call", { error });
+      throw new NetworkError("Failed to mute call", { cause: error });
+    }
+  }
+  /**
+   * Unmute a call (DELETE /calls/{call_id}/mute)
+   */
+  async unmuteCall(callId, accessToken) {
+    this.logger.debug("Unmuting call", { callId });
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/conversations/calls/${callId}/mute`, {
+        method: "DELETE",
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+      if (response.status === 401) {
+        throw new AuthenticationError("Authentication failed");
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new NetworkError(
+          `Failed to unmute call: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      this.logger.info("Call unmuted successfully", { callId });
+    } catch (error) {
+      if (error instanceof AuthenticationError || error instanceof NetworkError) {
+        throw error;
+      }
+      this.logger.error("Failed to unmute call", { error });
+      throw new NetworkError("Failed to unmute call", { cause: error });
+    }
+  }
+  /**
+   * Get call mute status (GET /calls/{call_id}/mute)
+   */
+  async getCallMuteStatus(callId, accessToken) {
+    this.logger.debug("Getting call mute status", { callId });
+    try {
+      const response = await fetch(`${this.apiUrl}/api/v1/conversations/calls/${callId}/mute`, {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+      if (response.status === 401) {
+        throw new AuthenticationError("Authentication failed");
+      }
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new NetworkError(
+          `Failed to get call mute status: ${response.status} ${response.statusText} - ${errorText}`
+        );
+      }
+      const data = await response.json();
+      this.logger.debug("Call mute status retrieved", { callId, muted: data.muted });
+      return data;
+    } catch (error) {
+      if (error instanceof AuthenticationError || error instanceof NetworkError) {
+        throw error;
+      }
+      this.logger.error("Failed to get call mute status", { error });
+      throw new NetworkError("Failed to get call mute status", { cause: error });
+    }
+  }
 };
 
 // src/conversation/Conversation.ts
 var Conversation = class extends EventEmitter {
-  constructor(id, options, authManager, apiUrl) {
+  constructor(id, options, authManager, urls) {
     super();
     this.logger = getLogger(["angany", "sdk", "conversation"]);
     this.state = "idle";
@@ -17195,12 +17385,17 @@ var Conversation = class extends EventEmitter {
     this.id = id;
     this.options = options;
     this.authManager = authManager;
-    this.apiUrl = apiUrl;
+    this.urls = urls;
+    const sseUrl = urls.sseUrl || urls.apiUrl;
     this.sipManager = new SipManager();
-    this.transcriptionService = new TranscriptionService(apiUrl);
-    this.apiService = new ApiService(apiUrl);
+    this.transcriptionService = new TranscriptionService(sseUrl);
+    this.apiService = new ApiService(urls.apiUrl);
     this.logger = this.logger.with({ conversationId: id, resource: options.resource });
-    this.logger.debug("Conversation created");
+    this.logger.debug("Conversation created", {
+      apiUrl: urls.apiUrl,
+      sseUrl,
+      sipUrl: urls.sipUrl || "will be derived"
+    });
   }
   /**
    * Initialize and start the conversation
@@ -17297,8 +17492,12 @@ var Conversation = class extends EventEmitter {
       if (this.ephemeralCredentials.sip.realm) {
         sipConfig.realm = this.ephemeralCredentials.sip.realm;
       }
-      if (this.ephemeralCredentials.sip.websocketUrl) {
+      if (this.urls.sipUrl) {
+        sipConfig.websocketUrl = this.urls.sipUrl;
+        this.logger.debug("Using configured SIP URL", { url: sipConfig.websocketUrl });
+      } else if (this.ephemeralCredentials.sip.websocketUrl) {
         sipConfig.websocketUrl = this.ephemeralCredentials.sip.websocketUrl;
+        this.logger.debug("Using platform-provided WebSocket URL", { url: sipConfig.websocketUrl });
       } else if (this.ephemeralCredentials.sip.uris && this.ephemeralCredentials.sip.uris.length > 0) {
         const wssUris = this.ephemeralCredentials.sip.uris.filter(
           (uri) => uri.includes("transport=wss")
@@ -17309,7 +17508,7 @@ var Conversation = class extends EventEmitter {
         const wsUri = publicUri || wssUris[0];
         if (wsUri) {
           this.logger.debug("Selected SIP URI", { uri: wsUri, isPublic: !!publicUri });
-          const apiDomain = new URL(this.apiUrl).hostname;
+          const apiDomain = new URL(this.urls.apiUrl).hostname;
           sipConfig.websocketUrl = `wss://${apiDomain}/api/webrtc/`;
           this.logger.debug("Derived WebSocket URL from API domain", {
             apiDomain,
@@ -17317,15 +17516,18 @@ var Conversation = class extends EventEmitter {
           });
         }
       }
-      if (sipConfig.websocketUrl) {
+      if (sipConfig.websocketUrl && !this.urls.sipUrl) {
         this.logger.debug("Original WebSocket URL", { url: sipConfig.websocketUrl });
         const privateIpPattern = /wss?:\/\/(192\.168\.|10\.|172\.(1[6-9]|2[0-9]|3[01])\.)/;
         if (privateIpPattern.test(sipConfig.websocketUrl)) {
           this.logger.warn("Detected private IP in WebSocket URL, replacing with API domain");
-          const apiDomain = new URL(this.apiUrl).hostname;
+          const apiDomain = new URL(this.urls.apiUrl).hostname;
           const originalUrl = sipConfig.websocketUrl;
           const correctedUrl = `wss://${apiDomain}/api/webrtc/`;
-          this.logger.debug("Extracted API domain", { domain: apiDomain, apiUrl: this.apiUrl });
+          this.logger.debug("Extracted API domain", {
+            domain: apiDomain,
+            apiUrl: this.urls.apiUrl
+          });
           sipConfig.websocketUrl = correctedUrl;
           this.logger.info("Corrected WebSocket URL", {
             original: originalUrl,
@@ -17397,11 +17599,11 @@ var Conversation = class extends EventEmitter {
     const sendVoiceOptions = {
       text,
       callId: this.callId,
-      muteAgent: this.agentMuted
+      interruptsConversation: options?.interruptsConversation,
+      queueWhenSpeaking: options?.queueWhenSpeaking,
+      muteAgent: options?.muteAgent,
+      voiceSettings: options?.voiceSettings
     };
-    if (options?.interrupt !== void 0) {
-      sendVoiceOptions.interrupt = options.interrupt;
-    }
     try {
       await this.apiService.sendVoice(sendVoiceOptions, this.accessToken);
     } catch (error) {
@@ -17488,6 +17690,118 @@ var Conversation = class extends EventEmitter {
   isAgentMuted() {
     return this.agentMuted;
   }
+  /**
+   * Get the current call ID (available after connection)
+   */
+  getCallId() {
+    return this.callId;
+  }
+  /**
+   * Mute the call via API (POST /calls/{call_id}/mute)
+   */
+  async muteCall() {
+    this.logger.debug("Muting call via API");
+    if (!this.callId) {
+      throw new ConversationError("No call ID available - call may not be connected yet");
+    }
+    if (!this.accessToken) {
+      throw new AuthenticationError("No access token available");
+    }
+    try {
+      await this.apiService.muteCall(this.callId, this.accessToken);
+      this.logger.info("Call muted via API", { callId: this.callId });
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        this.logger.debug("API call failed with auth error, attempting token refresh");
+        try {
+          const freshToken = await this.authManager.getAccessToken();
+          if (freshToken && freshToken !== this.accessToken) {
+            this.accessToken = freshToken;
+            this.logger.debug("Token refreshed, retrying mute call operation");
+            await this.apiService.muteCall(this.callId, this.accessToken);
+            return;
+          }
+          throw error;
+        } catch (refreshError) {
+          this.logger.error("Failed to refresh token for mute call operation", {
+            error: refreshError
+          });
+          throw error;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Unmute the call via API (DELETE /calls/{call_id}/mute)
+   */
+  async unmuteCall() {
+    this.logger.debug("Unmuting call via API");
+    if (!this.callId) {
+      throw new ConversationError("No call ID available - call may not be connected yet");
+    }
+    if (!this.accessToken) {
+      throw new AuthenticationError("No access token available");
+    }
+    try {
+      await this.apiService.unmuteCall(this.callId, this.accessToken);
+      this.logger.info("Call unmuted via API", { callId: this.callId });
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        this.logger.debug("API call failed with auth error, attempting token refresh");
+        try {
+          const freshToken = await this.authManager.getAccessToken();
+          if (freshToken && freshToken !== this.accessToken) {
+            this.accessToken = freshToken;
+            this.logger.debug("Token refreshed, retrying unmute call operation");
+            await this.apiService.unmuteCall(this.callId, this.accessToken);
+            return;
+          }
+          throw error;
+        } catch (refreshError) {
+          this.logger.error("Failed to refresh token for unmute call operation", {
+            error: refreshError
+          });
+          throw error;
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get call mute status via API (GET /calls/{call_id}/mute)
+   */
+  async getCallMuteStatus() {
+    this.logger.debug("Getting call mute status via API");
+    if (!this.callId) {
+      throw new ConversationError("No call ID available - call may not be connected yet");
+    }
+    if (!this.accessToken) {
+      throw new AuthenticationError("No access token available");
+    }
+    try {
+      return await this.apiService.getCallMuteStatus(this.callId, this.accessToken);
+    } catch (error) {
+      if (error instanceof AuthenticationError) {
+        this.logger.debug("API call failed with auth error, attempting token refresh");
+        try {
+          const freshToken = await this.authManager.getAccessToken();
+          if (freshToken && freshToken !== this.accessToken) {
+            this.accessToken = freshToken;
+            this.logger.debug("Token refreshed, retrying get call mute status operation");
+            return await this.apiService.getCallMuteStatus(this.callId, this.accessToken);
+          }
+          throw error;
+        } catch (refreshError) {
+          this.logger.error("Failed to refresh token for get call mute status operation", {
+            error: refreshError
+          });
+          throw error;
+        }
+      }
+      throw error;
+    }
+  }
   /**
    * Get conversation status
    */
@@ -17643,12 +17957,24 @@ var Conversation = class extends EventEmitter {
         speaker: event.speaker,
         text: event.text,
         timestamp: event.timestamp,
-        isFinal: event.isFinal
+        isFinal: event.isFinal,
+        humanTurnId: event.humanTurnId,
+        agentTurnId: event.agentTurnId,
+        speakerId: event.speakerId
       });
     });
     this.transcriptionService.on("callId", (callId) => {
       this.logger.info("Received call ID", { callId });
       this.callId = callId;
+      this.emit("callId", callId);
+    });
+    this.transcriptionService.on("callStarted", (callId) => {
+      this.logger.info("Call started", { callId });
+      this.emit("callStarted", callId);
+    });
+    this.transcriptionService.on("callEnded", (callId) => {
+      this.logger.info("Call ended", { callId });
+      this.emit("callEnded", callId);
     });
     this.transcriptionService.on("error", (error) => {
       this.logger.error("Transcription error", { error });
@@ -17706,8 +18032,12 @@ var AnganyVoice = class extends EventEmitter {
     this.logger = getLogger(["angany", "sdk", "core"]);
     this.conversations = /* @__PURE__ */ new Map();
     this.config = config;
-    this.auth = new AuthManager(config.apiUrl, config.apiUrl);
-    this.logger.debug("AnganyVoice initialized", { apiUrl: config.apiUrl });
+    this.auth = new AuthManager(config.apiUrl, config.issuer || config.apiUrl);
+    this.logger.debug("AnganyVoice initialized", {
+      apiUrl: config.apiUrl,
+      sseUrl: config.sseUrl || config.apiUrl,
+      sipUrl: config.sipUrl || "derived from apiUrl"
+    });
   }
   /**
    * Get the current configuration
@@ -17742,7 +18072,11 @@ var AnganyVoice = class extends EventEmitter {
         ...options
       },
       this.auth,
-      this.config.apiUrl
+      {
+        apiUrl: this.config.apiUrl,
+        sseUrl: this.config.sseUrl,
+        sipUrl: this.config.sipUrl
+      }
     );
     conversation.on("ended", () => {
       this.conversations.delete(conversationId);
@@ -17795,7 +18129,7 @@ var AnganyVoice = class extends EventEmitter {
 };
 
 // src/version.ts
-var VERSION = "0.0.1";
+var VERSION = "0.0.2";
 
 export { AnganyError, AnganyVoice, AuthManager, AuthenticationError, ConfigurationError, Conversation, ConversationError, ErrorCodes, EventEmitter, MediaError, NetworkError, PermissionError, ResourceError, VERSION, ValidationError, hasErrorCode, isAnganyError };
 //# sourceMappingURL=index.js.map