@superinterface/react 3.13.2 → 3.14.1

package/dist/index.js

@@ -10757,6 +10757,43 @@ function _asyncToGenerator12(n) {
         });
     };
 }
+var sentTypes = [
+    "session.created",
+    "response.done",
+    "conversation.item.input_audio_transcription.completed"
+];
+var handleThreadEvent = function(_ref) {
+    var event = _ref.event, superinterfaceContext = _ref.superinterfaceContext;
+    if (event.data.event === "thread.created") {
+        threadCreated({
+            value: event.data,
+            superinterfaceContext: superinterfaceContext
+        });
+    } else if (event.data.event === "thread.run.requires_action") {
+        threadRunRequiresAction({
+            value: event.data,
+            superinterfaceContext: superinterfaceContext
+        });
+    }
+};
+var handleOpenaiEvent = function(_ref2) {
+    var event = _ref2.event, openaiEventsDataChannel = _ref2.openaiEventsDataChannel;
+    openaiEventsDataChannel.send(JSON.stringify(event.data));
+};
+var handleEvent = function(_ref3) {
+    var event = _ref3.event, superinterfaceContext = _ref3.superinterfaceContext, openaiEventsDataChannel = _ref3.openaiEventsDataChannel;
+    if (event.type === "openaiEvent") {
+        return handleOpenaiEvent({
+            event: event,
+            openaiEventsDataChannel: openaiEventsDataChannel
+        });
+    } else if (event.type === "threadEvent") {
+        return handleThreadEvent({
+            event: event,
+            superinterfaceContext: superinterfaceContext
+        });
+    }
+};
 var useWebrtcAudioRuntime = function() {
     var startSessionIfNeeded = function startSessionIfNeeded() {
         return _startSessionIfNeeded.apply(this, arguments);
@@ -10834,41 +10871,18 @@ var useWebrtcAudioRuntime = function() {
     }
     function _initRealtimeSession() {
         _initRealtimeSession = _asyncToGenerator12(function() {
-            var searchParams, iceServersResponse, iceServersData, peerConn, audioEl, ms, offer, sdpResponse, reader, decoder, answerSdp, _ref, value, done, answer, err;
+            var peerConn, audioEl, openaiEventsDataChannel, ms, offer, searchParams_0, sdpResponse, answerSdp, answer, err1;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         _state.trys.push([
                             0,
-                            9,
+                            7,
                             ,
-                            10
+                            8
                         ]);
                         setUserIsPending(true);
-                        searchParams = new URLSearchParams(variableParams({
-                            variables: superinterfaceContext.variables,
-                            superinterfaceContext: superinterfaceContext
-                        }));
-                        return [
-                            4,
-                            fetch("".concat(superinterfaceContext.baseUrl, "/audio-runtimes/webrtc/ice-servers?").concat(searchParams), {
-                                method: "GET",
-                                headers: {
-                                    "Content-Type": "application/json"
-                                }
-                            })
-                        ];
-                    case 1:
-                        iceServersResponse = _state.sent();
-                        return [
-                            4,
-                            iceServersResponse.json()
-                        ];
-                    case 2:
-                        iceServersData = _state.sent();
-                        peerConn = new RTCPeerConnection({
-                            iceServers: iceServersData.iceServers
-                        });
+                        peerConn = new RTCPeerConnection();
                         pcRef.current = peerConn;
                         audioEl = document.createElement("audio");
                         audioEl.autoplay = true;
@@ -10881,35 +10895,115 @@ var useWebrtcAudioRuntime = function() {
                             setAssistantPaused(false);
                             setAssistantAudioPlayed(true);
                         };
-                        peerConn.createDataChannel("unused-negotiation-only");
-                        peerConn.addEventListener("datachannel", function(event) {
-                            var channel = event.channel;
-                            if (channel.label === "thread-events") {
-                                channel.onmessage = function(_ref) {
-                                    var data2 = _ref.data;
-                                    console.log("Data channel message:", data2);
-                                    var parsedData = JSON.parse(data2);
-                                    if (parsedData.event === "thread.created") {
-                                        threadCreated({
-                                            value: parsedData,
-                                            superinterfaceContext: superinterfaceContext
-                                        });
-                                    } else if (parsedData.event === "thread.run.requires_action") {
-                                        threadRunRequiresAction({
-                                            value: parsedData,
-                                            superinterfaceContext: superinterfaceContext
-                                        });
+                        openaiEventsDataChannel = peerConn.createDataChannel("oai-events");
+                        openaiEventsDataChannel.addEventListener("message", /* @__PURE__ */ function() {
+                            var _ref4 = _asyncToGenerator12(function(e) {
+                                var parsedData, searchParams, eventsResponse, reader, decoder, _ref, value, done, buffer, lines, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, line, event, ref;
+                                return _ts_generator(this, function(_state) {
+                                    switch(_state.label){
+                                        case 0:
+                                            parsedData = JSON.parse(e.data);
+                                            if (!sentTypes.includes(parsedData.type)) return [
+                                                2
+                                            ];
+                                            searchParams = new URLSearchParams(variableParams({
+                                                variables: superinterfaceContext.variables,
+                                                superinterfaceContext: superinterfaceContext
+                                            }));
+                                            return [
+                                                4,
+                                                fetch("".concat(superinterfaceContext.baseUrl, "/audio-runtimes/webrtc/events?").concat(searchParams), {
+                                                    method: "POST",
+                                                    headers: {
+                                                        "Content-Type": "application/json"
+                                                    },
+                                                    body: e.data
+                                                })
+                                            ];
+                                        case 1:
+                                            eventsResponse = _state.sent();
+                                            if (!eventsResponse.body) {
+                                                throw new Error("No body in events response");
+                                            }
+                                            reader = eventsResponse.body.getReader();
+                                            decoder = new TextDecoder("utf-8");
+                                            return [
+                                                4,
+                                                reader.read()
+                                            ];
+                                        case 2:
+                                            _ref = _state.sent(), value = _ref.value, done = _ref.done;
+                                            buffer = "";
+                                            _state.label = 3;
+                                        case 3:
+                                            if (!!done) return [
+                                                3,
+                                                5
+                                            ];
+                                            buffer += decoder.decode(value, {
+                                                stream: true
+                                            });
+                                            lines = buffer.split("\n");
+                                            buffer = lines.pop() || "";
+                                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                            try {
+                                                for(_iterator = lines[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                                    line = _step.value;
+                                                    if (line.trim()) {
+                                                        try {
+                                                            event = JSON.parse(line);
+                                                            handleEvent({
+                                                                event: event,
+                                                                superinterfaceContext: superinterfaceContext,
+                                                                openaiEventsDataChannel: openaiEventsDataChannel
+                                                            });
+                                                        } catch (error) {
+                                                            console.error("JSON parse error:", error, "Line:", line);
+                                                        }
+                                                    }
+                                                }
+                                            } catch (err) {
+                                                _didIteratorError = true;
+                                                _iteratorError = err;
+                                            } finally{
+                                                try {
+                                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                        _iterator.return();
+                                                    }
+                                                } finally{
+                                                    if (_didIteratorError) {
+                                                        throw _iteratorError;
+                                                    }
+                                                }
+                                            }
+                                            return [
+                                                4,
+                                                reader.read()
+                                            ];
+                                        case 4:
+                                            ref = _state.sent(), value = ref.value, done = ref.done, ref;
+                                            return [
+                                                3,
+                                                3
+                                            ];
+                                        case 5:
+                                            return [
+                                                2
+                                            ];
                                     }
-                                };
-                            }
-                        });
+                                });
+                            });
+                            return function(_x) {
+                                return _ref4.apply(this, arguments);
+                            };
+                        }());
                         return [
                             4,
                             navigator.mediaDevices.getUserMedia({
                                 audio: true
                             })
                         ];
-                    case 3:
+                    case 1:
                         ms = _state.sent();
                         localStreamRef.current = ms;
                         ms.getTracks().forEach(function(t) {
@@ -10920,17 +11014,21 @@ var useWebrtcAudioRuntime = function() {
                             4,
                             peerConn.createOffer()
                         ];
-                    case 4:
+                    case 2:
                         offer = _state.sent();
                         return [
                             4,
                             peerConn.setLocalDescription(offer)
                         ];
-                    case 5:
+                    case 3:
                         _state.sent();
+                        searchParams_0 = new URLSearchParams(variableParams({
+                            variables: superinterfaceContext.variables,
+                            superinterfaceContext: superinterfaceContext
+                        }));
                         return [
                             4,
-                            fetch("".concat(superinterfaceContext.baseUrl, "/audio-runtimes/webrtc?").concat(searchParams), {
+                            fetch("".concat(superinterfaceContext.baseUrl, "/audio-runtimes/webrtc?").concat(searchParams_0), {
                                 method: "POST",
                                 body: offer.sdp,
                                 headers: {
@@ -10938,30 +11036,17 @@ var useWebrtcAudioRuntime = function() {
                                 }
                             })
                         ];
-                    case 6:
+                    case 4:
                         sdpResponse = _state.sent();
                         if (!sdpResponse.ok) {
                             throw new Error("Server responded with status ".concat(sdpResponse.status));
                         }
-                        if (!sdpResponse.body) {
-                            throw new Error("ReadableStream not supported in this browser.");
-                        }
-                        reader = sdpResponse.body.getReader();
-                        decoder = new TextDecoder("utf-8");
-                        answerSdp = "";
                         return [
                             4,
-                            reader.read()
+                            sdpResponse.text()
                         ];
-                    case 7:
-                        _ref = _state.sent(), value = _ref.value, done = _ref.done;
-                        if (done) {
-                            throw new Error("Stream closed before SDP was received");
-                        }
-                        answerSdp += decoder.decode(value, {
-                            stream: true
-                        });
-                        console.log("Received SDP Answer:", answerSdp);
+                    case 5:
+                        answerSdp = _state.sent();
                         answer = {
                             type: "answer",
                             sdp: answerSdp
@@ -10970,7 +11055,7 @@ var useWebrtcAudioRuntime = function() {
                             4,
                             peerConn.setRemoteDescription(answer)
                         ];
-                    case 8:
+                    case 6:
                         _state.sent();
                         buildAnalyzers(ms, audioEl);
                         setUserIsPending(false);
@@ -10979,11 +11064,11 @@ var useWebrtcAudioRuntime = function() {
                         setAssistantPlaying(true);
                         return [
                             3,
-                            10
+                            8
                         ];
-                    case 9:
-                        err = _state.sent();
-                        console.error("Error initRealtimeSession:", err);
+                    case 7:
+                        err1 = _state.sent();
+                        console.error("Error initRealtimeSession:", err1);
                         setUserIsPending(false);
                         setRecorderStatus("stopped");
                         setAssistantPlaying(false);
@@ -10993,9 +11078,9 @@ var useWebrtcAudioRuntime = function() {
                         setAssistantAudioPlayed(false);
                         return [
                             3,
-                            10
+                            8
                         ];
-                    case 10:
+                    case 8:
                         return [
                             2
                         ];