sera-ai 1.0.13 → 1.0.15

package/dist/index.js

@@ -713,7 +713,7 @@ var useAudioRecovery = (reprocessSession) => {
         const store = transaction.objectStore(STORE_NAME);
         const session = {
           id: sessionId,
-          audioChunks: [],
+          audioChunks: {},
           metadata: {
             ...metadata,
             timestamp: Date.now(),
@@ -2716,9 +2716,11 @@ var createAudioProcessorWorker = () => {
           }
 
           if (event.data.command === "resetUploadChunk") {
+            // Only reset the upload flags, NOT the buffer
+            // The buffer is cleared after chunk data is extracted and sent
             this._uploadChunk = false;
             this._uploadingChunk = false;
-            this._buffer = [];
+            // NOTE: Do NOT clear buffer here - it's cleared in the chunk upload logic after data is sent
           }
 
           if (event.data.command === "pause") {
@@ -2866,6 +2868,7 @@ var useAudioRecorder = ({
   const [selectedModel, setSelectedModel] = React3__namespace.default.useState("new-large");
   const [isRetryingSession, setIsRetryingSession] = React3__namespace.default.useState(false);
   const [showRetrySessionPrompt, setShowRetrySessionPrompt] = React3__namespace.default.useState(false);
+  const sessionHasFailedChunkRef = React3__namespace.default.useRef(false);
   const effectiveApiKey = apiKey;
   const {
     convertTranscriptionResponse,
@@ -2891,8 +2894,8 @@ var useAudioRecorder = ({
     markSessionComplete,
     markSessionFailed,
     retrySession,
+    deleteSession,
     getFailedSession,
-    hasFailedSession,
     clearFailedSessions
   } = useAudioRecovery_default(async (audioChunks, metadata) => {
     try {
@@ -3055,15 +3058,6 @@ var useAudioRecorder = ({
       console.log("Speciality set, microphone validation will happen on recording start");
     }
   }, [speciality]);
-  React3__namespace.default.useEffect(() => {
-    const checkFailedSessions = async () => {
-      const failedSession = await hasFailedSession();
-      if (failedSession) {
-        setShowRetrySessionPrompt(true);
-      }
-    };
-    checkFailedSessions();
-  }, [hasFailedSession]);
   const clearAllSessions = React3__namespace.default.useCallback(async () => {
     await clearFailedSessions();
     setShowRetrySessionPrompt(false);
@@ -3078,8 +3072,8 @@ var useAudioRecorder = ({
         isFinalChunk,
         sequence,
         audioDataLength: audioData?.length,
-        requestFormat: selectedFormatRef.current
-        // Log the request format
+        requestFormat: selectedFormatRef.current,
+        sessionHasFailed: sessionHasFailedChunkRef.current
       });
       processorRef.current?.port.postMessage({ command: "resetUploadChunk" });
       if (audioData && localSessionIdRef.current && !retry) {
@@ -3093,6 +3087,14 @@ var useAudioRecorder = ({
       } else {
         console.log(`[DB] Skipping IndexedDB save: audioData=${!!audioData}, sessionId=${localSessionIdRef.current}, retry=${retry}`);
       }
+      if (sessionHasFailedChunkRef.current && !retry) {
+        console.log(`[SKIP] Session has failed chunk - skipping server upload for sequence ${sequence}, continuing to record audio`);
+        if (isFinalChunk) {
+          setShowRetrySessionPrompt(true);
+          setIsProcessing(false);
+        }
+        return;
+      }
       try {
         const data = await pRetry__default.default(
           async (attemptNumber) => {
@@ -3341,11 +3343,13 @@ var useAudioRecorder = ({
         }
         const isAbortError = err instanceof Error && err.name === "AbortError";
         const statusCode = err instanceof Error && err.message.includes("HTTP") ? parseInt(err.message.split("HTTP")[1].trim()) : null;
-        if (localSessionIdRef.current) {
+        if (localSessionIdRef.current && !retry) {
+          sessionHasFailedChunkRef.current = true;
           await markSessionFailed(
             localSessionIdRef.current,
             err instanceof Error ? err.message : "Unknown error"
           );
+          console.log(`[FAIL] Chunk ${sequence} failed - session marked as failed, will continue recording audio locally`);
           if (isFinalChunk) {
             setShowRetrySessionPrompt(true);
           }
@@ -3411,16 +3415,26 @@ var useAudioRecorder = ({
         const success = await retrySession(failedSession.id);
         if (success) {
           console.log(`Successfully retried session ${failedSession.id}`);
+          await deleteSession(failedSession.id);
+          console.log(`Deleted session ${failedSession.id} from IndexedDB after successful retry`);
           setError(null);
+          setShowRetrySessionPrompt(false);
+        } else {
+          console.log(`Retry failed for session ${failedSession.id} - keeping retry UI visible`);
+          setShowRetrySessionPrompt(true);
+          setError("Retry failed. Please check your connection and try again.");
         }
+      } else {
+        setShowRetrySessionPrompt(false);
       }
     } catch (error2) {
       console.error("Error retrying failed sessions:", error2);
       setError("Failed to retry sessions. Please try again.");
+      setShowRetrySessionPrompt(true);
     } finally {
       setIsRetryingSession(false);
     }
-  }, [retrySession, getFailedSession]);
+  }, [retrySession, getFailedSession, deleteSession]);
   const startRecording = React3__namespace.default.useCallback(async () => {
     try {
       setError(null);
@@ -3436,16 +3450,12 @@ var useAudioRecorder = ({
         sequenceCounterRef.current = 0;
         nextExpectedSequenceRef.current = 0;
         receivedTranscriptionsRef.current.clear();
+        sessionHasFailedChunkRef.current = false;
+        chunkQueueRef.current = [];
         const localSessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         localSessionIdRef.current = localSessionId;
         sessionIdRef.current = null;
         console.log("Created local session ID for IndexedDB:", localSessionId);
-        await createSession(localSessionId, {
-          patientId,
-          patientName: patientName || void 0,
-          patientHistory: patientHistory || void 0,
-          speciality
-        });
       }
       const stream = await navigator.mediaDevices.getUserMedia({
         audio: {
@@ -3469,6 +3479,15 @@ var useAudioRecorder = ({
         });
       }
       const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+      if (!isPaused && localSessionIdRef.current) {
+        await createSession(localSessionIdRef.current, {
+          patientId,
+          patientName: patientName || void 0,
+          patientHistory: patientHistory || void 0,
+          speciality,
+          sampleRate: audioContext.sampleRate
+        });
+      }
       const processorUrl = createAudioProcessorWorker();
       await audioContext.audioWorklet.addModule(processorUrl);
       URL.revokeObjectURL(processorUrl);
@@ -3574,6 +3593,14 @@ var useAudioRecorder = ({
       }, 500);
     }
     setIsRecording(false);
+    console.log("\u{1F50D} Stop recording - checking for failed session:", {
+      hasSessionFailed: sessionHasFailedChunkRef.current,
+      localSessionId: localSessionIdRef.current
+    });
+    if (sessionHasFailedChunkRef.current && localSessionIdRef.current) {
+      console.log("\u26A0\uFE0F Recording stopped with failed session - showing retry UI");
+      setShowRetrySessionPrompt(true);
+    }
   }, [uploadChunkInterval]);
   React3__namespace.default.useEffect(() => {
     const handleDeviceChange = async () => {
@@ -3647,13 +3674,14 @@ var useAudioRecorder = ({
     }, 47e3);
     setUploadChunkInterval(intervalId);
   }, [isPaused]);
-  const processNextChunkInQueue = React3__namespace.default.useCallback(() => {
-    if (isProcessingQueueRef.current || chunkQueueRef.current.length === 0) return;
+  const processNextChunkInQueue = React3__namespace.default.useCallback(async () => {
+    if (isProcessingQueueRef.current || chunkQueueRef.current.length === 0) {
+      return;
+    }
     const { chunk, isFinal, sequence, isPaused: isPaused2 = false } = chunkQueueRef.current.shift();
     console.log(`[QUEUE] Processing chunk ${sequence} from queue, remaining: ${chunkQueueRef.current.length}`);
     isProcessingQueueRef.current = true;
     uploadChunkToServer(chunk, isFinal, sequence, false, isPaused2).finally(() => {
-      console.log(`[QUEUE] Finished processing chunk ${sequence}`);
       isProcessingQueueRef.current = false;
       processNextChunkInQueue();
     });
@@ -3662,7 +3690,11 @@ var useAudioRecorder = ({
     (audioData, isFinalChunk, sequence, isPausedChunk = false) => {
       console.log(`[QUEUE] Enqueuing ${isFinalChunk ? "FINAL" : isPausedChunk ? "PAUSED" : "regular"} chunk ${sequence}, samples: ${audioData?.length || 0}, queue size: ${chunkQueueRef.current.length}`);
       if (isFinalChunk) {
-        setIsProcessing(true);
+        if (!sessionHasFailedChunkRef.current) {
+          setIsProcessing(true);
+        } else {
+          console.log("\u26A0\uFE0F Session has failed - skipping processing state (IndexedDB save only)");
+        }
       }
       chunkQueueRef.current.push({
         chunk: audioData,