@anganyai/voice-sdk 0.0.2 → 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");
@@ -16599,7 +16609,9 @@ var SipManager = class extends EventEmitter {
             this.remoteStream = event.streams[0];
             this.logger.info("Remote audio stream received via ontrack fallback");
             if (isReactNative()) {
-              this.logger.info("React Native: Remote audio from ontrack will be played automatically");
+              this.logger.info(
+                "React Native: Remote audio from ontrack will be played automatically"
+              );
             } else {
               this.createAudioElement();
               if (this.audioElement && this.remoteStream) {
@@ -16644,7 +16656,9 @@ var SipManager = class extends EventEmitter {
    */
   createAudioElement() {
     if (isReactNative()) {
-      this.logger.debug("React Native detected - skipping audio element creation (handled by WebRTC)");
+      this.logger.debug(
+        "React Native detected - skipping audio element creation (handled by WebRTC)"
+      );
       return;
     }
     if (!isBrowser()) {
@@ -16921,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",
@@ -17051,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(),
@@ -17065,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 });
@@ -17136,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 {
@@ -17150,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
           })
         }
       );
@@ -17239,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";
@@ -17252,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
@@ -17354,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")
@@ -17366,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,
@@ -17374,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,
@@ -17454,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) {
@@ -17545,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
    */
@@ -17700,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 });
@@ -17763,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
@@ -17799,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);