@superinterface/react 3.13.1 → 3.14.0

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,7 +10871,7 @@ var useWebrtcAudioRuntime = function() {
     }
     function _initRealtimeSession() {
         _initRealtimeSession = _asyncToGenerator12(function() {
-            var iceServers, peerConn, audioEl, ms, offer, searchParams, sdpResponse, reader, decoder, answerSdp, _ref, value, done, answer, err;
+            var searchParams, peerConn, audioEl, openaiEventsDataChannel, ms, offer, sdpResponse, answerSdp, answer, err1;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -10845,30 +10882,11 @@ var useWebrtcAudioRuntime = function() {
                             8
                         ]);
                         setUserIsPending(true);
-                        iceServers = [
-                            {
-                                url: "stun:global.stun.twilio.com:3478",
-                                urls: "stun:global.stun.twilio.com:3478"
-                            },
-                            {
-                                urls: "stun:stun.l.google.com:19302"
-                            },
-                            {
-                                urls: "stun:stun1.l.google.com:19302"
-                            },
-                            {
-                                urls: "stun:stun2.l.google.com:19302"
-                            },
-                            {
-                                urls: "stun:stun4.l.google.com:19302"
-                            },
-                            {
-                                urls: "stun:stun.stunprotocol.org:3478"
-                            }
-                        ];
-                        peerConn = new RTCPeerConnection({
-                            iceServers: iceServers
-                        });
+                        searchParams = new URLSearchParams(variableParams({
+                            variables: superinterfaceContext.variables,
+                            superinterfaceContext: superinterfaceContext
+                        }));
+                        peerConn = new RTCPeerConnection();
                         pcRef.current = peerConn;
                         audioEl = document.createElement("audio");
                         audioEl.autoplay = true;
@@ -10881,28 +10899,104 @@ 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, 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
+                                            ];
+                                            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({
@@ -10928,10 +11022,6 @@ var useWebrtcAudioRuntime = function() {
                         ];
                     case 3:
                         _state.sent();
-                        searchParams = new URLSearchParams(variableParams({
-                            variables: superinterfaceContext.variables,
-                            superinterfaceContext: superinterfaceContext
-                        }));
                         return [
                             4,
                             fetch("".concat(superinterfaceContext.baseUrl, "/audio-runtimes/webrtc?").concat(searchParams), {
@@ -10947,25 +11037,12 @@ var useWebrtcAudioRuntime = function() {
                         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 5:
-                        _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);
+                        answerSdp = _state.sent();
                         answer = {
                             type: "answer",
                             sdp: answerSdp
@@ -10986,8 +11063,8 @@ var useWebrtcAudioRuntime = function() {
                             8
                         ];
                     case 7:
-                        err = _state.sent();
-                        console.error("Error initRealtimeSession:", err);
+                        err1 = _state.sent();
+                        console.error("Error initRealtimeSession:", err1);
                         setUserIsPending(false);
                         setRecorderStatus("stopped");
                         setAssistantPlaying(false);