@defcomm/meetingsdk 0.5.6 → 0.5.7

package/dist/index.mjs

@@ -1802,28 +1802,44 @@ var SFUClient = class {
       "audio/webm",
       "audio/ogg;codecs=opus"
     ];
-    return candidates.find((type) => MediaRecorder.isTypeSupported(type)) || "";
+    return candidates.find(
+      (type) => MediaRecorder.isTypeSupported(type)
+    ) || "";
   }
-  async startLiveTranscription(audioTrack, speakerName) {
-    if (this.liveTranscriptionActive) return;
-    if (!this.room) throw new Error("Cannot start live transcription without a room");
-    if (!this.authToken) throw new Error("Cannot start live transcription without an authenticated token");
-    if (!audioTrack || audioTrack.kind !== "audio") {
-      throw new Error("A live microphone audio track is required");
+  async startLiveTranscription() {
+    if (this.liveTranscriptionActive) {
+      return;
+    }
+    if (!this.room) {
+      throw new Error("Cannot start live transcription without a room");
+    }
+    if (!this.authToken) {
+      throw new Error(
+        "Cannot start live transcription without an authenticated token"
+      );
+    }
+    const audioTrack = this.localStream?.getAudioTracks()[0];
+    if (!audioTrack || audioTrack.readyState !== "live") {
+      throw new Error(
+        "Cannot start live transcription without a live microphone track"
+      );
     }
     const mimeType = this.getLiveTranscriptionMimeType();
+    const stream = new MediaStream([audioTrack]);
     this.liveTranscriptionActive = true;
     this.liveTranscriptionSequence = 0;
     this.liveTranscriptionStartedAt = Date.now();
-    const stream = new MediaStream([audioTrack]);
-    this.liveTranscriptionLoopPromise = this.runLiveTranscriptionLoop(
-      stream,
+    console.log("[Transcript] starting", {
+      room: this.room,
+      trackId: audioTrack.id,
+      readyState: audioTrack.readyState,
+      enabled: audioTrack.enabled,
       mimeType
-    ).finally(() => {
+    });
+    this.liveTranscriptionLoopPromise = this.runLiveTranscriptionLoop(stream, mimeType).finally(() => {
       this.liveTranscriptionRecorder = null;
       this.liveTranscriptionLoopPromise = null;
     });
-    void speakerName;
     await Promise.resolve();
   }
   async captureLiveChunk(stream, mimeType) {
@@ -1831,21 +1847,32 @@ var SFUClient = class {
       const chunks = [];
       const recorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream);
       this.liveTranscriptionRecorder = recorder;
-      const timeout = setTimeout(() => {
-        if (recorder.state !== "inactive") recorder.stop();
-      }, 4500);
+      const timeout = window.setTimeout(() => {
+        if (recorder.state !== "inactive") {
+          recorder.stop();
+        }
+      }, 1500);
+      recorder.onstart = () => {
+        console.log("[Transcript] MediaRecorder started", {
+          mimeType: recorder.mimeType
+        });
+      };
       recorder.ondataavailable = (event) => {
-        if (event.data.size > 0) chunks.push(event.data);
+        if (event.data.size > 0) {
+          chunks.push(event.data);
+        }
       };
       recorder.onerror = () => {
-        clearTimeout(timeout);
+        window.clearTimeout(timeout);
         reject(new Error("Live transcription recorder failed"));
       };
       recorder.onstop = () => {
-        clearTimeout(timeout);
+        window.clearTimeout(timeout);
         this.liveTranscriptionRecorder = null;
         resolve(
-          chunks.length ? new Blob(chunks, { type: recorder.mimeType || mimeType || "audio/webm" }) : null
+          chunks.length ? new Blob(chunks, {
+            type: recorder.mimeType || mimeType || "audio/webm"
+          }) : null
         );
       };
       recorder.start();
@@ -1855,52 +1882,86 @@ var SFUClient = class {
     while (this.liveTranscriptionActive && stream.getAudioTracks()[0]?.readyState === "live") {
       try {
         const blob = await this.captureLiveChunk(stream, mimeType);
-        if (!this.liveTranscriptionActive) break;
-        if (!blob || blob.size === 0) continue;
+        if (!this.liveTranscriptionActive) {
+          break;
+        }
+        if (!blob || blob.size === 0) {
+          continue;
+        }
         const sequence = this.liveTranscriptionSequence++;
-        const offsetMs = Math.max(0, Date.now() - this.liveTranscriptionStartedAt);
-        await this.uploadLiveTranscriptionChunk(blob, sequence, offsetMs, mimeType);
+        const offsetMs = Math.max(
+          0,
+          Date.now() - this.liveTranscriptionStartedAt
+        );
+        await this.uploadLiveTranscriptionChunk(
+          blob,
+          sequence,
+          offsetMs,
+          blob.type || mimeType
+        );
       } catch (error) {
+        console.error(
+          "[Transcript] chunk processing failed",
+          error
+        );
         this.onError(error);
-        await new Promise((resolve) => setTimeout(resolve, 750));
+        await new Promise(
+          (resolve) => setTimeout(resolve, 750)
+        );
       }
     }
   }
   async uploadLiveTranscriptionChunk(blob, sequence, offsetMs, mimeType) {
-    if (!this.room || !this.authToken) return;
+    if (!this.room || !this.authToken) {
+      return;
+    }
     const form = new FormData();
     form.append("sequence", String(sequence));
     form.append("offset_ms", String(offsetMs));
     const extension = mimeType.includes("ogg") || blob.type.includes("ogg") ? "ogg" : "webm";
-    form.append("audio", blob, `live-${sequence}.${extension}`);
-    const response = await fetch(
-      `${this.apiBase}/rooms/${encodeURIComponent(this.room)}/live-transcription`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${this.authToken}`,
-          Accept: "application/json"
-        },
-        body: form
-      }
+    form.append(
+      "audio",
+      blob,
+      `live-${sequence}.${extension}`
     );
+    const url = `${this.apiBase}/rooms/${encodeURIComponent(this.room)}/live-transcription`;
+    console.log("[Transcript] POST", {
+      url,
+      sequence,
+      size: blob.size,
+      mimeType
+    });
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.authToken}`,
+        Accept: "application/json"
+      },
+      body: form
+    });
+    const responseText = await response.text();
+    console.log("[Transcript] response", {
+      status: response.status,
+      body: responseText
+    });
     if (!response.ok) {
-      let detail = `Live transcription request failed: ${response.status}`;
-      try {
-        const body = await response.json();
-        detail = body?.message || body?.detail || detail;
-      } catch {
-      }
-      throw new Error(detail);
+      throw new Error(
+        `Live transcription request failed: ${response.status} ${responseText}`
+      );
     }
   }
   stopLiveTranscription() {
+    console.log("[Transcript] stopping");
     this.liveTranscriptionActive = false;
     try {
-      if (this.liveTranscriptionRecorder?.state !== "inactive") {
-        this.liveTranscriptionRecorder?.stop();
+      if (this.liveTranscriptionRecorder && this.liveTranscriptionRecorder.state !== "inactive") {
+        this.liveTranscriptionRecorder.stop();
       }
-    } catch {
+    } catch (error) {
+      console.warn(
+        "[Transcript] recorder shutdown failed",
+        error
+      );
     }
     this.liveTranscriptionRecorder = null;
   }
@@ -3132,13 +3193,10 @@ var VideoSDKCore = class {
       throw new Error("SFU client is not connected");
     }
     const audioTrack = this.localStream?.getAudioTracks()[0];
-    if (!audioTrack) {
+    if (!audioTrack || audioTrack.readyState !== "live") {
       throw new Error("Microphone audio track is not available");
     }
-    await this.sfuClient.startLiveTranscription(
-      audioTrack,
-      this.participantName
-    );
+    await this.sfuClient.startLiveTranscription();
   }
   stopLiveTranscription() {
     this.sfuClient?.stopLiveTranscription();