@ourlu/assistant-sdk 0.2.0

package/dist/iife/audio.v1.js

@@ -0,0 +1,179 @@
+(function() {
+  "use strict";
+  var runtime = window.__CompanionWidgetRuntimeV1 || (window.__CompanionWidgetRuntimeV1 = {});
+  if (!runtime.utils) {
+    throw new Error("Widget runtime utils module must be loaded first.");
+  }
+
+  var mergeTranscript = runtime.utils.mergeTranscript;
+  var resolveRecorderMimeType = runtime.utils.resolveRecorderMimeType;
+  var encodeArrayBufferToBase64 = runtime.utils.encodeArrayBufferToBase64;
+
+  function WidgetAudioManager(state, api, ui) {
+    this.state = state;
+    this.api = api;
+    this.ui = ui;
+    this.stream = null;
+    this.recorder = null;
+    this.chunks = [];
+    this.stopDraftStream = null;
+    this.activeAudioSessionId = "";
+    this.cleanupTimer = null;
+    this._starting = false;
+    this._stopping = false;
+  }
+
+  WidgetAudioManager.prototype.isSupported = function() {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && typeof MediaRecorder !== "undefined");
+  };
+
+  WidgetAudioManager.prototype.toggle = async function() {
+    if (this._starting || this._stopping) return;
+    if (this.state.listening) return this.stop();
+    return this.start();
+  };
+
+  WidgetAudioManager.prototype.start = async function() {
+    if (!this.isSupported() || this.state.sending || this._starting || this._stopping) return;
+    this._starting = true;
+    this.ui.setMicListening(true);
+    try {
+      this.ui.showError("");
+      this.clearDraftCleanup();
+      if (this.activeAudioSessionId && this.state.sessionId) {
+        try {
+          await this.api.closeAudioSession(this.state.sessionId, this.activeAudioSessionId);
+        } catch (_) { /* best-effort */ }
+        this.activeAudioSessionId = "";
+      }
+      var sessionId = await this.api.ensureSession();
+      if (this.stopDraftStream) this.stopDraftStream();
+      this.stopDraftStream = await this.api.streamAudioDraft(sessionId, {
+        onDelta: this.handleDraftDelta.bind(this),
+        onComplete: this.handleDraftComplete.bind(this),
+        onError: this.handleDraftError.bind(this),
+        onTransportError: this.handleDraftTransportError.bind(this)
+      });
+      var audioSession = await this.api.startAudioSession(sessionId);
+      this.activeAudioSessionId = audioSession.audio_session_id || "";
+      this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      this.chunks = [];
+      var mimeType = resolveRecorderMimeType();
+      this.recorder = new MediaRecorder(this.stream, mimeType ? { mimeType: mimeType } : {});
+      var self = this;
+      this.recorder.ondataavailable = function(event) {
+        if (event.data && event.data.size > 0) self.chunks.push(event.data);
+      };
+      this.recorder.start(250);
+      this.state.listening = true;
+    } catch (error) {
+      this.cleanupMedia();
+      this.activeAudioSessionId = "";
+      this.state.listening = false;
+      this.ui.setMicListening(false);
+      this.ui.showError("Erreur démarrage audio : " + (error.message || error));
+    } finally {
+      this._starting = false;
+    }
+  };
+
+  WidgetAudioManager.prototype.stop = async function() {
+    if (!this.state.listening || this._stopping) return;
+    this._stopping = true;
+    this.state.listening = false;
+    this.ui.setMicListening(false);
+    var sessionId = this.state.sessionId;
+    var audioSessionId = this.activeAudioSessionId;
+    try {
+      var blob = await this.stopRecorder();
+      if (blob && blob.size > 0 && sessionId && audioSessionId) {
+        var base64 = encodeArrayBufferToBase64(await blob.arrayBuffer());
+        await this.api.sendAudioChunk(sessionId, audioSessionId, base64);
+      }
+      if (sessionId && audioSessionId) await this.api.closeAudioSession(sessionId, audioSessionId);
+    } catch (error) {
+      this.ui.showError("Erreur fermeture audio : " + (error.message || error));
+    } finally {
+      this.activeAudioSessionId = "";
+      this._stopping = false;
+      this.scheduleDraftCleanup();
+    }
+  };
+
+  WidgetAudioManager.prototype.stopRecorder = function() {
+    var self = this;
+    if (!this.recorder) {
+      this.cleanupMedia();
+      return Promise.resolve(new Blob());
+    }
+    return new Promise(function(resolve) {
+      var recorder = self.recorder;
+      function done() {
+        var blob = new Blob(self.chunks, { type: recorder.mimeType || "audio/webm" });
+        self.cleanupMedia();
+        resolve(blob);
+      }
+      if (recorder.state === "inactive") return done();
+      recorder.addEventListener("stop", done, { once: true });
+      recorder.stop();
+    });
+  };
+
+  WidgetAudioManager.prototype.cleanupMedia = function() {
+    if (this.recorder) {
+      this.recorder.ondataavailable = null;
+      this.recorder = null;
+    }
+    if (this.stream) {
+      this.stream.getTracks().forEach(function(track) { track.stop(); });
+      this.stream = null;
+    }
+    this.chunks = [];
+  };
+
+  WidgetAudioManager.prototype.handleDraftDelta = function(payload) {
+    if (!payload || !payload.delta) return;
+    this.ui.setInput(mergeTranscript(this.ui.inputValue(), payload.delta));
+  };
+
+  WidgetAudioManager.prototype.handleDraftComplete = function(payload) {
+    if (payload && payload.text) this.ui.setInput(String(payload.text).trim());
+    this.scheduleDraftCleanup();
+  };
+
+  WidgetAudioManager.prototype.handleDraftError = function(payload) {
+    this.ui.showError((payload && payload.message) || "Erreur transcription audio");
+    this.scheduleDraftCleanup();
+  };
+
+  WidgetAudioManager.prototype.isExpectedStreamAbortMessage = function(message) {
+    var normalized = String(message || "").toLowerCase();
+    return normalized.indexOf("aborted") !== -1 ||
+      normalized.indexOf("aborterror") !== -1 ||
+      normalized.indexOf("body stream buffer was aborted") !== -1 ||
+      normalized.indexOf("the operation was aborted") !== -1;
+  };
+
+  WidgetAudioManager.prototype.handleDraftTransportError = function(message) {
+    if (this.isExpectedStreamAbortMessage(message)) return;
+    this.ui.showError(message || "Erreur stream audio");
+  };
+
+  WidgetAudioManager.prototype.clearDraftCleanup = function() {
+    if (!this.cleanupTimer) return;
+    clearTimeout(this.cleanupTimer);
+    this.cleanupTimer = null;
+  };
+
+  WidgetAudioManager.prototype.scheduleDraftCleanup = function() {
+    var self = this;
+    this.clearDraftCleanup();
+    this.cleanupTimer = setTimeout(function() {
+      if (self.stopDraftStream) self.stopDraftStream();
+      self.stopDraftStream = null;
+      self.cleanupTimer = null;
+    }, 3000);
+  };
+
+  runtime.WidgetAudioManager = WidgetAudioManager;
+})();