@defcomm/meetingsdk 0.5.6 → 0.5.8

package/dist/index.mjs

@@ -440,11 +440,7 @@ var SFUClient = class {
     this.trackToSource = /* @__PURE__ */ new Map();
     this.localTrackIds = /* @__PURE__ */ new Map();
     this.subscriberStatsTimer = null;
-    this.liveTranscriptionActive = false;
-    this.liveTranscriptionSequence = 0;
-    this.liveTranscriptionStartedAt = 0;
-    this.liveTranscriptionRecorder = null;
-    this.liveTranscriptionLoopPromise = null;
+    this.liveTranscriptionSeen = false;
     this.networkProfile = null;
     this.heartbeatTimer = null;
     this.apiBase = options.apiBase || "https://api.example.com/api";
@@ -1112,7 +1108,10 @@ var SFUClient = class {
           end_ms: payload.end_ms == null ? null : Number(payload.end_ms),
           timestamp: String(payload.timestamp ?? (/* @__PURE__ */ new Date()).toISOString())
         };
-        if (transcript.text.trim()) this.onLiveTranscript(transcript);
+        if (transcript.text.trim()) {
+          this.liveTranscriptionSeen = true;
+          this.onLiveTranscript(transcript);
+        }
         break;
       }
       case "network_quality": {
@@ -1793,119 +1792,63 @@ var SFUClient = class {
       }
     });
   }
-  getLiveTranscriptionMimeType() {
-    if (typeof MediaRecorder === "undefined") {
-      throw new Error("MediaRecorder is not supported by this browser");
+  /**
+   * Transcription is server-authoritative. The SFU reads the already-published
+   * microphone RTP stream, sends audio to the configured transcription service,
+   * persists final segments, and broadcasts LiveTranscript events.
+   *
+   * These methods remain as compatibility shims for applications that used the
+   * previous browser MediaRecorder-based API. They intentionally do not capture
+   * or upload microphone audio from the browser.
+   */
+  async startLiveTranscription() {
+    if (!this.room) {
+      throw new Error("Cannot start live transcription without a room");
     }
-    const candidates = [
-      "audio/webm;codecs=opus",
-      "audio/webm",
-      "audio/ogg;codecs=opus"
-    ];
-    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");
-    }
-    const mimeType = this.getLiveTranscriptionMimeType();
-    this.liveTranscriptionActive = true;
-    this.liveTranscriptionSequence = 0;
-    this.liveTranscriptionStartedAt = Date.now();
-    const stream = new MediaStream([audioTrack]);
-    this.liveTranscriptionLoopPromise = this.runLiveTranscriptionLoop(
-      stream,
-      mimeType
-    ).finally(() => {
-      this.liveTranscriptionRecorder = null;
-      this.liveTranscriptionLoopPromise = null;
-    });
-    void speakerName;
-    await Promise.resolve();
+    console.info("[Transcript] server-authoritative live transcription is managed by the SFU");
   }
-  async captureLiveChunk(stream, mimeType) {
-    return new Promise((resolve, reject) => {
-      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);
-      recorder.ondataavailable = (event) => {
-        if (event.data.size > 0) chunks.push(event.data);
-      };
-      recorder.onerror = () => {
-        clearTimeout(timeout);
-        reject(new Error("Live transcription recorder failed"));
-      };
-      recorder.onstop = () => {
-        clearTimeout(timeout);
-        this.liveTranscriptionRecorder = null;
-        resolve(
-          chunks.length ? new Blob(chunks, { type: recorder.mimeType || mimeType || "audio/webm" }) : null
-        );
-      };
-      recorder.start();
-    });
+  stopLiveTranscription() {
+    console.info("[Transcript] server-authoritative live transcription remains managed by the SFU");
   }
-  async runLiveTranscriptionLoop(stream, mimeType) {
-    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;
-        const sequence = this.liveTranscriptionSequence++;
-        const offsetMs = Math.max(0, Date.now() - this.liveTranscriptionStartedAt);
-        await this.uploadLiveTranscriptionChunk(blob, sequence, offsetMs, mimeType);
-      } catch (error) {
-        this.onError(error);
-        await new Promise((resolve) => setTimeout(resolve, 750));
-      }
-    }
+  isLiveTranscriptionActive() {
+    return this.liveTranscriptionSeen;
   }
-  async uploadLiveTranscriptionChunk(blob, sequence, offsetMs, mimeType) {
-    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}`);
+  async getTranscript(roomCode, sessionId) {
+    if (!this.authToken) throw new Error("Authentication token is required");
+    const query = sessionId ? `?session_id=${encodeURIComponent(sessionId)}` : "";
     const response = await fetch(
-      `${this.apiBase}/rooms/${encodeURIComponent(this.room)}/live-transcription`,
+      `${this.apiBase}/rooms/${encodeURIComponent(roomCode)}/transcript${query}`,
       {
-        method: "POST",
+        method: "GET",
         headers: {
           Authorization: `Bearer ${this.authToken}`,
           Accept: "application/json"
-        },
-        body: form
+        }
       }
     );
+    const text = await response.text();
     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(`Transcript request failed: ${response.status} ${text}`);
     }
+    return JSON.parse(text);
   }
-  stopLiveTranscription() {
-    this.liveTranscriptionActive = false;
-    try {
-      if (this.liveTranscriptionRecorder?.state !== "inactive") {
-        this.liveTranscriptionRecorder?.stop();
+  async getMeetingSummary(roomCode, sessionId) {
+    if (!this.authToken) throw new Error("Authentication token is required");
+    const response = await fetch(
+      `${this.apiBase}/rooms/${encodeURIComponent(roomCode)}/transcript/${encodeURIComponent(sessionId)}/summary`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          Accept: "application/json"
+        }
       }
-    } catch {
+    );
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Meeting summary request failed: ${response.status} ${text}`);
     }
-    this.liveTranscriptionRecorder = null;
-  }
-  isLiveTranscriptionActive() {
-    return this.liveTranscriptionActive;
+    return JSON.parse(text);
   }
   async applyNetworkRecommendation(action) {
     if (!this.videoSender || this.networkProfile === action) return;
@@ -2348,6 +2291,12 @@ var VideoSDKCore = class {
   async deleteRoom(roomCode) {
     return this.sfuClient.deleteRoom(roomCode);
   }
+  async getTranscript(roomCode, sessionId) {
+    return this.sfuClient.getTranscript(roomCode, sessionId);
+  }
+  async getMeetingSummary(roomCode, sessionId) {
+    return this.sfuClient.getMeetingSummary(roomCode, sessionId);
+  }
   // JOIN
   async joinMeeting(config) {
     const { roomId, name, audioMuted = false, videoMuted = false } = config;
@@ -3132,13 +3081,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();
@@ -3404,6 +3350,8 @@ var MeetingProvider = ({
       createRoom: sdk.createRoom.bind(sdk),
       getRoom: sdk.getRoom.bind(sdk),
       deleteRoom: sdk.deleteRoom.bind(sdk),
+      getTranscript: sdk.getTranscript.bind(sdk),
+      getMeetingSummary: sdk.getMeetingSummary.bind(sdk),
       toggleMic: sdk.toggleMic.bind(sdk),
       toggleCam: sdk.toggleCam.bind(sdk),
       startScreenShare: sdk.startScreenShare.bind(sdk),