@anganyai/voice-sdk 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -16423,6 +16423,18 @@ var SipManager = class extends EventEmitter {
       }
       const inviter = new Inviter(this.userAgent, uri, inviterOptions);
       this.currentSession = inviter;
+      let rejectionReason;
+      inviter.delegate = {
+        onReject: (response) => {
+          const statusCode = response.message.statusCode;
+          const reasonPhrase = response.message.reasonPhrase;
+          this.logger.warn("Call rejected", { statusCode, reasonPhrase });
+          rejectionReason = {
+            code: statusCode,
+            reason: this.mapSipErrorToMessage(statusCode, reasonPhrase)
+          };
+        }
+      };
       inviter.stateChange.addListener((state) => {
         this.logger.debug("Call state changed", { state });
         switch (state) {
@@ -16436,6 +16448,9 @@ var SipManager = class extends EventEmitter {
             break;
           case SessionState2.Terminated:
             this.setState("registered");
+            if (rejectionReason) {
+              this.emit("error", new Error(rejectionReason.reason));
+            }
             this.emit("callEnded");
             this.cleanupAudioResources();
             delete this.currentSession;
@@ -16901,6 +16916,50 @@ var SipManager = class extends EventEmitter {
       }
     }, delay);
   }
+  /**
+   * Map SIP error codes to user-friendly messages
+   */
+  mapSipErrorToMessage(statusCode, reasonPhrase) {
+    const errorMessages = {
+      // 4xx Client Errors
+      400: "Invalid request",
+      401: "Authentication required",
+      403: "Access denied",
+      404: "Agent not found",
+      408: "Request timeout",
+      480: "Agent unavailable",
+      486: "Agent is busy",
+      487: "Call cancelled",
+      488: "Not acceptable",
+      // 5xx Server Errors
+      500: "Server error",
+      502: "Bad gateway",
+      503: "Service unavailable",
+      504: "Gateway timeout",
+      // 6xx Global Failures
+      600: "Agent is busy",
+      603: "Agent declined the call",
+      604: "Agent does not exist",
+      606: "Not acceptable"
+    };
+    const message = errorMessages[statusCode];
+    if (message) {
+      return message;
+    }
+    if (reasonPhrase) {
+      return reasonPhrase;
+    }
+    if (statusCode >= 400 && statusCode < 500) {
+      return "Call failed";
+    }
+    if (statusCode >= 500 && statusCode < 600) {
+      return "Server error";
+    }
+    if (statusCode >= 600) {
+      return "Agent unavailable";
+    }
+    return "Unknown error";
+  }
 };
 
 // src/services/TranscriptionService.ts
@@ -16912,8 +16971,18 @@ var TranscriptionService = class extends EventEmitter {
     this.maxReconnectAttempts = 5;
     this.reconnectDelay = 1e3;
     this.isIntentionallyClosed = false;
+    this.useEventSource = false;
     this.apiUrl = apiUrl;
   }
+  /**
+   * Set EventSource factory for React Native environments
+   * Call this before start() to use EventSource instead of fetch streams
+   */
+  setEventSourceFactory(factory) {
+    this.eventSourceFactory = factory;
+    this.useEventSource = true;
+    this.logger.debug("EventSource factory set - will use EventSource mode");
+  }
   /**
    * Set token refresh callback for handling expired tokens
    */
@@ -16943,7 +17012,10 @@ var TranscriptionService = class extends EventEmitter {
    */
   async connectToSSE(accessToken, isRetry = false) {
     const sseUrl = `${this.apiUrl}/api/v1/events?event_types=transcription,call_event`;
-    this.logger.debug("Connecting to SSE endpoint", { url: sseUrl, isRetry });
+    this.logger.debug("Connecting to SSE endpoint", { url: sseUrl, isRetry, useEventSource: this.useEventSource });
+    if (this.useEventSource && this.eventSourceFactory) {
+      return this.connectWithEventSource(sseUrl, accessToken);
+    }
     const response = await fetch(sseUrl, {
       method: "GET",
       headers: {
@@ -16981,6 +17053,65 @@ var TranscriptionService = class extends EventEmitter {
     this.reader = response.body.getReader();
     this.processStream();
   }
+  /**
+   * Connect using EventSource (for React Native)
+   */
+  connectWithEventSource(sseUrl, accessToken) {
+    if (!this.eventSourceFactory) {
+      throw new Error("EventSource factory not set");
+    }
+    this.logger.debug("Connecting with EventSource", { url: sseUrl });
+    if (this.eventSource) {
+      this.eventSource.removeAllEventListeners();
+      this.eventSource.close();
+    }
+    this.eventSource = this.eventSourceFactory(sseUrl, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: "text/event-stream",
+        "Cache-Control": "no-cache"
+      }
+    });
+    this.eventSource.addEventListener("open", () => {
+      this.logger.info("EventSource SSE connection established");
+      this.reconnectAttempts = 0;
+      this.emit("connected");
+    });
+    this.eventSource.addEventListener("message", (event) => {
+      this.logger.debug("EventSource message received", { data: event.data });
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch (error) {
+        this.logger.error("Error parsing EventSource message", { error, data: event.data });
+      }
+    });
+    this.eventSource.addEventListener("error", (event) => {
+      this.logger.error("EventSource error", { event });
+      if (!this.isIntentionallyClosed) {
+        this.emit("disconnected");
+        this.handleReconnection();
+      }
+    });
+    this.eventSource.addEventListener("transcription", (event) => {
+      this.logger.debug("EventSource transcription event", { data: event.data });
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage({ ...data, type: "transcription" });
+      } catch (error) {
+        this.logger.error("Error parsing transcription event", { error, data: event.data });
+      }
+    });
+    this.eventSource.addEventListener("call_event", (event) => {
+      this.logger.debug("EventSource call_event", { data: event.data });
+      try {
+        const data = JSON.parse(event.data);
+        this.handleMessage(data);
+      } catch (error) {
+        this.logger.error("Error parsing call_event", { error, data: event.data });
+      }
+    });
+  }
   /**
    * Stop the SSE connection
    */
@@ -16991,6 +17122,11 @@ var TranscriptionService = class extends EventEmitter {
       clearTimeout(this.reconnectTimeout);
       delete this.reconnectTimeout;
     }
+    if (this.eventSource) {
+      this.eventSource.removeAllEventListeners();
+      this.eventSource.close();
+      delete this.eventSource;
+    }
     if (this.reader) {
       this.reader.cancel();
       delete this.reader;
@@ -17404,6 +17540,14 @@ var Conversation = class extends EventEmitter {
       sipUrl: urls.sipUrl || "will be derived"
     });
   }
+  /**
+   * Set EventSource factory for React Native environments
+   * Call this before initialize() to use EventSource instead of fetch streams for SSE
+   */
+  setEventSourceFactory(factory) {
+    this.transcriptionService.setEventSourceFactory(factory);
+    this.logger.debug("EventSource factory configured for transcription service");
+  }
   /**
    * Initialize and start the conversation
    */
@@ -18101,6 +18245,10 @@ var AnganyVoice = class extends EventEmitter {
       this.conversations.delete(conversationId);
       this.emit("conversationEnded", conversationId);
     });
+    if (this.config.eventSourceFactory) {
+      this.logger.debug("Setting EventSource factory for conversation");
+      conversation.setEventSourceFactory(this.config.eventSourceFactory);
+    }
     try {
       this.logger.debug("Initializing conversation...");
       await conversation.initialize();