@defcomm/meetingsdk 0.5.7 → 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,180 +1792,63 @@ var SFUClient = class {
       }
     });
   }
-  getLiveTranscriptionMimeType() {
-    if (typeof MediaRecorder === "undefined") {
-      throw new Error("MediaRecorder is not supported by this browser");
-    }
-    const candidates = [
-      "audio/webm;codecs=opus",
-      "audio/webm",
-      "audio/ogg;codecs=opus"
-    ];
-    return candidates.find(
-      (type) => MediaRecorder.isTypeSupported(type)
-    ) || "";
-  }
+  /**
+   * 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.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();
-    console.log("[Transcript] starting", {
-      room: this.room,
-      trackId: audioTrack.id,
-      readyState: audioTrack.readyState,
-      enabled: audioTrack.enabled,
-      mimeType
-    });
-    this.liveTranscriptionLoopPromise = this.runLiveTranscriptionLoop(stream, mimeType).finally(() => {
-      this.liveTranscriptionRecorder = null;
-      this.liveTranscriptionLoopPromise = null;
-    });
-    await Promise.resolve();
-  }
-  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 = 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);
-        }
-      };
-      recorder.onerror = () => {
-        window.clearTimeout(timeout);
-        reject(new Error("Live transcription recorder failed"));
-      };
-      recorder.onstop = () => {
-        window.clearTimeout(timeout);
-        this.liveTranscriptionRecorder = null;
-        resolve(
-          chunks.length ? new Blob(chunks, {
-            type: recorder.mimeType || mimeType || "audio/webm"
-          }) : null
-        );
-      };
-      recorder.start();
-    });
+    console.info("[Transcript] server-authoritative live transcription is 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;
+  stopLiveTranscription() {
+    console.info("[Transcript] server-authoritative live transcription remains managed by the SFU");
+  }
+  isLiveTranscriptionActive() {
+    return this.liveTranscriptionSeen;
+  }
+  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(roomCode)}/transcript${query}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.authToken}`,
+          Accept: "application/json"
         }
-        const sequence = this.liveTranscriptionSequence++;
-        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)
-        );
       }
-    }
-  }
-  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}`
     );
-    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
-    });
+    const text = await response.text();
     if (!response.ok) {
-      throw new Error(
-        `Live transcription request failed: ${response.status} ${responseText}`
-      );
+      throw new Error(`Transcript request failed: ${response.status} ${text}`);
     }
+    return JSON.parse(text);
   }
-  stopLiveTranscription() {
-    console.log("[Transcript] stopping");
-    this.liveTranscriptionActive = false;
-    try {
-      if (this.liveTranscriptionRecorder && 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 (error) {
-      console.warn(
-        "[Transcript] recorder shutdown failed",
-        error
-      );
+    );
+    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;
@@ -2409,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;
@@ -3462,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),