@ourlu/assistant-sdk 0.2.3 → 0.2.5

package/dist/iife/audio.v1.70af81b3.js

@@ -0,0 +1,191 @@
+(function() {
+  "use strict";
+  var runtime = window.__OurluWidgetRuntimeV1 || (window.__OurluWidgetRuntimeV1 = {});
+  if (!runtime.utils) {
+    throw new Error("Widget runtime utils module must be loaded first.");
+  }
+
+  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._recording = false;
+    this._processing = false;
+  }
+
+  WidgetAudioManager.prototype.isSupported = function() {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && typeof MediaRecorder !== "undefined");
+  };
+
+  WidgetAudioManager.prototype.toggle = async function() {
+    if (this._processing) return;
+    if (this._recording) return this.stop();
+    return this.start();
+  };
+
+  WidgetAudioManager.prototype.start = async function() {
+    if (!this.isSupported() || this.state.sending || this._recording || this._processing) return;
+    this.ui.showError("");
+    this.ui.setInput("");
+    this.ui.setMicListening(true);
+    try {
+      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._recording = true;
+      this.state.listening = true;
+    } catch (error) {
+      this.cleanupMedia();
+      this._recording = false;
+      this.state.listening = false;
+      this.ui.setMicListening(false);
+      this.ui.showError("Erreur démarrage micro : " + (error.message || error));
+    }
+  };
+
+  WidgetAudioManager.prototype.stop = async function() {
+    if (!this._recording) return;
+    this._recording = false;
+    this._processing = true;
+    this.state.listening = false;
+    this.ui.setMicListening(false);
+    this.ui.setComposerDisabled(true);
+    this.ui.setInputPlaceholder("Transcription en cours…");
+    try {
+      var blobAndSession = await Promise.all([
+        this.collectRecordedBlob(),
+        this.api.ensureSession()
+      ]);
+      var blob = blobAndSession[0];
+      var sessionId = blobAndSession[1];
+      this.cleanupMedia();
+      if (!blob || blob.size === 0) {
+        this.ui.showError("Aucun audio enregistré.");
+        return;
+      }
+      var base64 = encodeArrayBufferToBase64(await blob.arrayBuffer());
+      var transcription = this.openTranscriptionListener(sessionId);
+      var audioSession = await this.api.startAudioSession(sessionId);
+      var audioSessionId = audioSession.audio_session_id || "";
+      await this.api.sendAudioChunk(sessionId, audioSessionId, base64);
+      transcription.setAudioSessionId(audioSessionId);
+      await transcription.connected;
+      await this.api.closeAudioSession(sessionId, audioSessionId);
+      var transcribedText = await transcription.result;
+      if (transcribedText) {
+        this.ui.setInput(transcribedText);
+      }
+    } catch (error) {
+      this.cleanupMedia();
+      this.ui.showError("Erreur transcription audio : " + (error.message || error));
+    } finally {
+      this._processing = false;
+      this.ui.setInputPlaceholder("");
+      this.ui.setComposerDisabled(false);
+    }
+  };
+
+  WidgetAudioManager.prototype.openTranscriptionListener = function(sessionId) {
+    var resolved = false;
+    var stopStream = null;
+    var expectedAudioSessionId = "";
+    var resolveResult, rejectResult, resolveConnected;
+    var resultPromise = new Promise(function(res, rej) { resolveResult = res; rejectResult = rej; });
+    var connectedPromise = new Promise(function(res) { resolveConnected = res; });
+    var timeout = setTimeout(function() {
+      if (!resolved) {
+        resolved = true;
+        if (stopStream) stopStream();
+        rejectResult(new Error("Transcription audio : délai dépassé."));
+      }
+    }, 30000);
+    function belongsToCurrentSession(payload) {
+      if (!expectedAudioSessionId) return true;
+      var payloadAudioId = payload && payload.audio_session_id ? payload.audio_session_id : "";
+      return !payloadAudioId || payloadAudioId === expectedAudioSessionId;
+    }
+    this.api.streamAudioDraft(sessionId, {
+      onDelta: function() {},
+      onComplete: function(payload) {
+        if (resolved || !belongsToCurrentSession(payload)) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        resolveResult(payload && payload.text ? String(payload.text).trim() : "");
+      },
+      onError: function(payload) {
+        if (resolved || !belongsToCurrentSession(payload)) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        rejectResult(new Error((payload && payload.message) || "Erreur transcription audio"));
+      },
+      onTransportError: function(message) {
+        if (resolved) return;
+        var normalized = String(message || "").toLowerCase();
+        var isAbort = normalized.indexOf("aborted") !== -1 || normalized.indexOf("aborterror") !== -1;
+        if (isAbort) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        rejectResult(new Error(message || "Erreur stream audio"));
+      }
+    }).then(function(stop) {
+      stopStream = stop;
+      resolveConnected();
+    }).catch(function(err) {
+      resolveConnected();
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        rejectResult(err);
+      }
+    });
+    return {
+      connected: connectedPromise,
+      result: resultPromise,
+      setAudioSessionId: function(id) { expectedAudioSessionId = id; }
+    };
+  };
+
+  WidgetAudioManager.prototype.collectRecordedBlob = function() {
+    var self = this;
+    if (!this.recorder) 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" });
+        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 = [];
+  };
+
+  runtime.WidgetAudioManager = WidgetAudioManager;
+})();

package/dist/iife/audio.v1.95146620.js

@@ -40,6 +40,7 @@
     try {
       this.ui.showError("");
       this.clearDraftCleanup();
+      this.stream = await navigator.mediaDevices.getUserMedia({ audio: true });
       if (this.activeAudioSessionId && this.state.sessionId) {
         try {
           await this.api.closeAudioSession(this.state.sessionId, this.activeAudioSessionId);
@@ -56,7 +57,6 @@
       });
       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 } : {});

package/dist/iife/audio.v1.b330baaf.js

@@ -0,0 +1,166 @@
+(function() {
+  "use strict";
+  var runtime = window.__OurluWidgetRuntimeV1 || (window.__OurluWidgetRuntimeV1 = {});
+  if (!runtime.utils) {
+    throw new Error("Widget runtime utils module must be loaded first.");
+  }
+
+  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._recording = false;
+    this._processing = false;
+  }
+
+  WidgetAudioManager.prototype.isSupported = function() {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && typeof MediaRecorder !== "undefined");
+  };
+
+  WidgetAudioManager.prototype.toggle = async function() {
+    if (this._processing) return;
+    if (this._recording) return this.stop();
+    return this.start();
+  };
+
+  WidgetAudioManager.prototype.start = async function() {
+    if (!this.isSupported() || this.state.sending || this._recording || this._processing) return;
+    try {
+      this.ui.showError("");
+      this.ui.setInput("");
+      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._recording = true;
+      this.state.listening = true;
+      this.ui.setMicListening(true);
+    } catch (error) {
+      this.cleanupMedia();
+      this.state.listening = false;
+      this.ui.setMicListening(false);
+      this.ui.showError("Erreur démarrage micro : " + (error.message || error));
+    }
+  };
+
+  WidgetAudioManager.prototype.stop = async function() {
+    if (!this._recording) return;
+    this._recording = false;
+    this._processing = true;
+    this.state.listening = false;
+    this.ui.setMicListening(false);
+    this.ui.setComposerDisabled(true);
+    try {
+      var blob = await this.collectRecordedBlob();
+      this.cleanupMedia();
+      if (!blob || blob.size === 0) {
+        this.ui.showError("Aucun audio enregistré.");
+        return;
+      }
+      var base64 = encodeArrayBufferToBase64(await blob.arrayBuffer());
+      var sessionId = await this.api.ensureSession();
+      var audioSession = await this.api.startAudioSession(sessionId);
+      var audioSessionId = audioSession.audio_session_id || "";
+      await this.api.sendAudioChunk(sessionId, audioSessionId, base64);
+      var transcriptionPromise = this.waitForTranscription(sessionId, audioSessionId);
+      await this.api.closeAudioSession(sessionId, audioSessionId);
+      var transcribedText = await transcriptionPromise;
+      if (transcribedText) {
+        this.ui.setInput(transcribedText);
+      }
+    } catch (error) {
+      this.cleanupMedia();
+      this.ui.showError("Erreur transcription audio : " + (error.message || error));
+    } finally {
+      this._processing = false;
+      this.ui.setComposerDisabled(false);
+    }
+  };
+
+  WidgetAudioManager.prototype.waitForTranscription = function(sessionId, audioSessionId) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      var resolved = false;
+      var timeout = setTimeout(function() {
+        if (!resolved) {
+          resolved = true;
+          if (stopStream) stopStream();
+          reject(new Error("Transcription audio : délai dépassé."));
+        }
+      }, 30000);
+      function belongsToCurrentSession(payload) {
+        if (!audioSessionId) return true;
+        var payloadAudioId = payload && payload.audio_session_id ? payload.audio_session_id : "";
+        return !payloadAudioId || payloadAudioId === audioSessionId;
+      }
+      var stopStream = null;
+      self.api.streamAudioDraft(sessionId, {
+        onDelta: function() {},
+        onComplete: function(payload) {
+          if (resolved || !belongsToCurrentSession(payload)) return;
+          resolved = true;
+          clearTimeout(timeout);
+          if (stopStream) stopStream();
+          resolve(payload && payload.text ? String(payload.text).trim() : "");
+        },
+        onError: function(payload) {
+          if (resolved || !belongsToCurrentSession(payload)) return;
+          resolved = true;
+          clearTimeout(timeout);
+          if (stopStream) stopStream();
+          reject(new Error((payload && payload.message) || "Erreur transcription audio"));
+        },
+        onTransportError: function(message) {
+          if (resolved) return;
+          var normalized = String(message || "").toLowerCase();
+          var isAbort = normalized.indexOf("aborted") !== -1 || normalized.indexOf("aborterror") !== -1;
+          if (isAbort) return;
+          resolved = true;
+          clearTimeout(timeout);
+          if (stopStream) stopStream();
+          reject(new Error(message || "Erreur stream audio"));
+        }
+      }).then(function(stop) { stopStream = stop; });
+    });
+  };
+
+  WidgetAudioManager.prototype.collectRecordedBlob = function() {
+    var self = this;
+    if (!this.recorder) 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" });
+        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 = [];
+  };
+
+  runtime.WidgetAudioManager = WidgetAudioManager;
+})();

package/dist/iife/audio.v1.bb9c2d88.js

@@ -0,0 +1,181 @@
+(function() {
+  "use strict";
+  var runtime = window.__OurluWidgetRuntimeV1 || (window.__OurluWidgetRuntimeV1 = {});
+  if (!runtime.utils) {
+    throw new Error("Widget runtime utils module must be loaded first.");
+  }
+
+  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._recording = false;
+    this._processing = false;
+  }
+
+  WidgetAudioManager.prototype.isSupported = function() {
+    return !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia && typeof MediaRecorder !== "undefined");
+  };
+
+  WidgetAudioManager.prototype.toggle = async function() {
+    if (this._processing) return;
+    if (this._recording) return this.stop();
+    return this.start();
+  };
+
+  WidgetAudioManager.prototype.start = async function() {
+    if (!this.isSupported() || this.state.sending || this._recording || this._processing) return;
+    try {
+      this.ui.showError("");
+      this.ui.setInput("");
+      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._recording = true;
+      this.state.listening = true;
+      this.ui.setMicListening(true);
+    } catch (error) {
+      this.cleanupMedia();
+      this.state.listening = false;
+      this.ui.setMicListening(false);
+      this.ui.showError("Erreur démarrage micro : " + (error.message || error));
+    }
+  };
+
+  WidgetAudioManager.prototype.stop = async function() {
+    if (!this._recording) return;
+    this._recording = false;
+    this._processing = true;
+    this.state.listening = false;
+    this.ui.setMicListening(false);
+    this.ui.setComposerDisabled(true);
+    try {
+      var blob = await this.collectRecordedBlob();
+      this.cleanupMedia();
+      if (!blob || blob.size === 0) {
+        this.ui.showError("Aucun audio enregistré.");
+        return;
+      }
+      this.ui.setInputPlaceholder("Transcription en cours…");
+      var base64 = encodeArrayBufferToBase64(await blob.arrayBuffer());
+      var sessionId = await this.api.ensureSession();
+      var audioSession = await this.api.startAudioSession(sessionId);
+      var audioSessionId = audioSession.audio_session_id || "";
+      await this.api.sendAudioChunk(sessionId, audioSessionId, base64);
+      var transcription = this.openTranscriptionListener(sessionId, audioSessionId);
+      await transcription.connected;
+      await this.api.closeAudioSession(sessionId, audioSessionId);
+      var transcribedText = await transcription.result;
+      this.ui.setInputPlaceholder("");
+      if (transcribedText) {
+        this.ui.setInput(transcribedText);
+      }
+    } catch (error) {
+      this.cleanupMedia();
+      this.ui.showError("Erreur transcription audio : " + (error.message || error));
+    } finally {
+      this._processing = false;
+      this.ui.setInputPlaceholder("");
+      this.ui.setComposerDisabled(false);
+    }
+  };
+
+  WidgetAudioManager.prototype.openTranscriptionListener = function(sessionId, audioSessionId) {
+    var resolved = false;
+    var stopStream = null;
+    var resolveResult, rejectResult, resolveConnected;
+    var resultPromise = new Promise(function(res, rej) { resolveResult = res; rejectResult = rej; });
+    var connectedPromise = new Promise(function(res) { resolveConnected = res; });
+    var timeout = setTimeout(function() {
+      if (!resolved) {
+        resolved = true;
+        if (stopStream) stopStream();
+        rejectResult(new Error("Transcription audio : délai dépassé."));
+      }
+    }, 30000);
+    function belongsToCurrentSession(payload) {
+      if (!audioSessionId) return true;
+      var payloadAudioId = payload && payload.audio_session_id ? payload.audio_session_id : "";
+      return !payloadAudioId || payloadAudioId === audioSessionId;
+    }
+    this.api.streamAudioDraft(sessionId, {
+      onDelta: function() {},
+      onComplete: function(payload) {
+        if (resolved || !belongsToCurrentSession(payload)) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        resolveResult(payload && payload.text ? String(payload.text).trim() : "");
+      },
+      onError: function(payload) {
+        if (resolved || !belongsToCurrentSession(payload)) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        rejectResult(new Error((payload && payload.message) || "Erreur transcription audio"));
+      },
+      onTransportError: function(message) {
+        if (resolved) return;
+        var normalized = String(message || "").toLowerCase();
+        var isAbort = normalized.indexOf("aborted") !== -1 || normalized.indexOf("aborterror") !== -1;
+        if (isAbort) return;
+        resolved = true;
+        clearTimeout(timeout);
+        if (stopStream) stopStream();
+        rejectResult(new Error(message || "Erreur stream audio"));
+      }
+    }).then(function(stop) {
+      stopStream = stop;
+      resolveConnected();
+    }).catch(function(err) {
+      resolveConnected();
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        rejectResult(err);
+      }
+    });
+    return { connected: connectedPromise, result: resultPromise };
+  };
+
+  WidgetAudioManager.prototype.collectRecordedBlob = function() {
+    var self = this;
+    if (!this.recorder) 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" });
+        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 = [];
+  };
+
+  runtime.WidgetAudioManager = WidgetAudioManager;
+})();