ui-soxo-bootstrap-core 2.6.40-dev.1 → 2.6.40-dev.11

package/core/modules/steps/openai-realtime.js

@@ -1,275 +1,275 @@
-const DEFAULT_MODEL =
-  process.env.OPENAI_REALTIME_MODEL ||
-  process.env.REACT_APP_OPENAI_REALTIME_MODEL ||
-  'gpt-realtime';
-const DEFAULT_VOICE =
-  process.env.OPENAI_REALTIME_VOICE ||
-  process.env.REACT_APP_OPENAI_REALTIME_VOICE ||
-  'alloy';
-const DEFAULT_CALLS_ENDPOINT =
-  process.env.OPENAI_REALTIME_ENDPOINT ||
-  process.env.REACT_APP_OPENAI_REALTIME_ENDPOINT ||
-  'https://api.openai.com/v1/realtime/calls';
-const DEFAULT_TOKEN_ENDPOINT =
-  process.env.OPENAI_REALTIME_TOKEN_ENDPOINT ||
-  process.env.REACT_APP_OPENAI_REALTIME_TOKEN_ENDPOINT ||
-  '';
-const DEFAULT_INSTRUCTIONS =
-  process.env.OPENAI_REALTIME_INSTRUCTIONS ||
-  process.env.REACT_APP_OPENAI_REALTIME_INSTRUCTIONS ||
-  'You are a warm, concise healthcare concierge assisting a guest during a guided process.';
-
-function getFromStorage(storageKey) {
-  if (typeof window === 'undefined' || !window.localStorage) {
-    return null;
-  }
-
-  try {
-    return window.localStorage.getItem(storageKey);
-  } catch (error) {
-    return null;
-  }
-}
-
-function resolveOpenAIKey() {
-  return (
-    process.env.OPENAI_API_KEY ||
-    process.env.OPEN_AI_KEY ||
-    process.env.REACT_APP_OPENAI_API_KEY ||
-    process.env.REACT_APP_OPEN_AI_KEY ||
-    getFromStorage('openai_api_key') ||
-    getFromStorage('open_ai_key') ||
-    getFromStorage('OPENAI_API_KEY') ||
-    getFromStorage('OPEN_AI_KEY') ||
-    getFromStorage('REACT_APP_OPENAI_API_KEY') ||
-    getFromStorage('REACT_APP_OPEN_AI_KEY') ||
-    null
-  );
-}
-
-async function fetchEphemeralKey(tokenEndpoint) {
-  const response = await fetch(tokenEndpoint, {
-    method: 'GET',
-    headers: { 'Content-Type': 'application/json' },
-  });
-
-  if (!response.ok) {
-    throw new Error(`OpenAI token endpoint failed with status ${response.status}`);
-  }
-
-  const payload = await response.json().catch(() => null);
-
-  return (
-    payload?.client_secret?.value ||
-    payload?.session?.client_secret?.value ||
-    payload?.value ||
-    null
-  );
-}
-
-async function resolveRealtimeKey(tokenEndpoint) {
-  if (tokenEndpoint) {
-    const key = await fetchEphemeralKey(tokenEndpoint);
-    if (key) {
-      return key;
-    }
-
-    throw new Error('OpenAI token endpoint did not return a client secret');
-  }
-
-  const key = resolveOpenAIKey();
-  if (key) {
-    return key;
-  }
-
-  throw new Error('OpenAI Realtime credentials are missing. Set OPEN_AI_KEY or configure OPENAI_REALTIME_TOKEN_ENDPOINT.');
-}
-
-export function hasOpenAIRealtimeCredentials(tokenEndpoint = DEFAULT_TOKEN_ENDPOINT) {
-  if (tokenEndpoint) {
-    return true;
-  }
-
-  return Boolean(resolveOpenAIKey());
-}
-
-export function createOpenAIRealtimeSession({
-  model = DEFAULT_MODEL,
-  voice = DEFAULT_VOICE,
-  instructions = DEFAULT_INSTRUCTIONS,
-  callsEndpoint = DEFAULT_CALLS_ENDPOINT,
-  tokenEndpoint = DEFAULT_TOKEN_ENDPOINT,
-  onEvent = () => {},
-  onStatus = () => {},
-  onError = () => {},
-} = {}) {
-  let peerConnection = null;
-  let dataChannel = null;
-  let localStream = null;
-  let audioElement = null;
-
-  const state = {
-    status: 'idle',
-  };
-
-  function updateStatus(status) {
-    state.status = status;
-    onStatus(status);
-  }
-
-  function sendEvent(eventPayload) {
-    if (!dataChannel || dataChannel.readyState !== 'open') {
-      return;
-    }
-
-    dataChannel.send(JSON.stringify(eventPayload));
-  }
-
-  function configureSession() {
-    sendEvent({
-      type: 'session.update',
-      session: {
-        instructions,
-        output_modalities: ['audio'],
-        audio: {
-          output: {
-            voice,
-          },
-          input: {
-            turn_detection: {
-              type: 'semantic_vad',
-              create_response: true,
-              interrupt_response: true,
-            },
-          },
-        },
-      },
-    });
-  }
-
-  async function connect() {
-    if (peerConnection) {
-      return;
-    }
-
-    updateStatus('connecting');
-
-    try {
-      if (typeof window === 'undefined' || typeof navigator === 'undefined') {
-        throw new Error('OpenAI Realtime requires a browser environment');
-      }
-
-      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
-        throw new Error('Microphone access is not available in this browser');
-      }
-
-      const token = await resolveRealtimeKey(tokenEndpoint);
-
-      peerConnection = new RTCPeerConnection();
-      dataChannel = peerConnection.createDataChannel('oai-events');
-
-      dataChannel.addEventListener('message', (event) => {
-        try {
-          const payload = JSON.parse(event.data);
-          onEvent(payload);
-        } catch (error) {
-          onError(error);
-        }
-      });
-
-      dataChannel.addEventListener('open', () => {
-        configureSession();
-      });
-
-      localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
-      localStream.getTracks().forEach((track) => peerConnection.addTrack(track, localStream));
-
-      audioElement = document.createElement('audio');
-      audioElement.autoplay = true;
-
-      peerConnection.addEventListener('track', (event) => {
-        const stream = event.streams?.[0];
-        if (stream && audioElement.srcObject !== stream) {
-          audioElement.srcObject = stream;
-        }
-      });
-
-      const offer = await peerConnection.createOffer();
-      await peerConnection.setLocalDescription(offer);
-
-      const response = await fetch(callsEndpoint, {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${token}`,
-          'Content-Type': 'application/sdp',
-        },
-        body: offer.sdp,
-      });
-
-      if (!response.ok) {
-        throw new Error(`OpenAI Realtime SDP exchange failed with status ${response.status}`);
-      }
-
-      const answer = await response.text();
-      await peerConnection.setRemoteDescription({ type: 'answer', sdp: answer });
-
-      updateStatus('connected');
-    } catch (error) {
-      updateStatus('error');
-      onError(error);
-      disconnect();
-      throw error;
-    }
-  }
-
-  function disconnect() {
-    updateStatus('idle');
-
-    if (dataChannel) {
-      dataChannel.close();
-      dataChannel = null;
-    }
-
-    if (peerConnection) {
-      peerConnection.close();
-      peerConnection = null;
-    }
-
-    if (localStream) {
-      localStream.getTracks().forEach((track) => track.stop());
-      localStream = null;
-    }
-
-    if (audioElement) {
-      audioElement.srcObject = null;
-      audioElement = null;
-    }
-  }
-
-  function sendText(text) {
-    if (!text) {
-      return;
-    }
-
-    sendEvent({
-      type: 'conversation.item.create',
-      item: {
-        type: 'message',
-        role: 'user',
-        content: [{ type: 'input_text', text }],
-      },
-    });
-
-    sendEvent({ type: 'response.create' });
-  }
-
-  return {
-    connect,
-    disconnect,
-    sendText,
-    sendEvent,
-    get status() {
-      return state.status;
-    },
-  };
-}
+const DEFAULT_MODEL =
+  process.env.OPENAI_REALTIME_MODEL ||
+  process.env.REACT_APP_OPENAI_REALTIME_MODEL ||
+  'gpt-realtime';
+const DEFAULT_VOICE =
+  process.env.OPENAI_REALTIME_VOICE ||
+  process.env.REACT_APP_OPENAI_REALTIME_VOICE ||
+  'alloy';
+const DEFAULT_CALLS_ENDPOINT =
+  process.env.OPENAI_REALTIME_ENDPOINT ||
+  process.env.REACT_APP_OPENAI_REALTIME_ENDPOINT ||
+  'https://api.openai.com/v1/realtime/calls';
+const DEFAULT_TOKEN_ENDPOINT =
+  process.env.OPENAI_REALTIME_TOKEN_ENDPOINT ||
+  process.env.REACT_APP_OPENAI_REALTIME_TOKEN_ENDPOINT ||
+  '';
+const DEFAULT_INSTRUCTIONS =
+  process.env.OPENAI_REALTIME_INSTRUCTIONS ||
+  process.env.REACT_APP_OPENAI_REALTIME_INSTRUCTIONS ||
+  'You are a warm, concise healthcare concierge assisting a guest during a guided process.';
+
+function getFromStorage(storageKey) {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    return null;
+  }
+
+  try {
+    return window.localStorage.getItem(storageKey);
+  } catch (error) {
+    return null;
+  }
+}
+
+function resolveOpenAIKey() {
+  return (
+    process.env.OPENAI_API_KEY ||
+    process.env.OPEN_AI_KEY ||
+    process.env.REACT_APP_OPENAI_API_KEY ||
+    process.env.REACT_APP_OPEN_AI_KEY ||
+    getFromStorage('openai_api_key') ||
+    getFromStorage('open_ai_key') ||
+    getFromStorage('OPENAI_API_KEY') ||
+    getFromStorage('OPEN_AI_KEY') ||
+    getFromStorage('REACT_APP_OPENAI_API_KEY') ||
+    getFromStorage('REACT_APP_OPEN_AI_KEY') ||
+    null
+  );
+}
+
+async function fetchEphemeralKey(tokenEndpoint) {
+  const response = await fetch(tokenEndpoint, {
+    method: 'GET',
+    headers: { 'Content-Type': 'application/json' },
+  });
+
+  if (!response.ok) {
+    throw new Error(`OpenAI token endpoint failed with status ${response.status}`);
+  }
+
+  const payload = await response.json().catch(() => null);
+
+  return (
+    payload?.client_secret?.value ||
+    payload?.session?.client_secret?.value ||
+    payload?.value ||
+    null
+  );
+}
+
+async function resolveRealtimeKey(tokenEndpoint) {
+  if (tokenEndpoint) {
+    const key = await fetchEphemeralKey(tokenEndpoint);
+    if (key) {
+      return key;
+    }
+
+    throw new Error('OpenAI token endpoint did not return a client secret');
+  }
+
+  const key = resolveOpenAIKey();
+  if (key) {
+    return key;
+  }
+
+  throw new Error('OpenAI Realtime credentials are missing. Set OPEN_AI_KEY or configure OPENAI_REALTIME_TOKEN_ENDPOINT.');
+}
+
+export function hasOpenAIRealtimeCredentials(tokenEndpoint = DEFAULT_TOKEN_ENDPOINT) {
+  if (tokenEndpoint) {
+    return true;
+  }
+
+  return Boolean(resolveOpenAIKey());
+}
+
+export function createOpenAIRealtimeSession({
+  model = DEFAULT_MODEL,
+  voice = DEFAULT_VOICE,
+  instructions = DEFAULT_INSTRUCTIONS,
+  callsEndpoint = DEFAULT_CALLS_ENDPOINT,
+  tokenEndpoint = DEFAULT_TOKEN_ENDPOINT,
+  onEvent = () => {},
+  onStatus = () => {},
+  onError = () => {},
+} = {}) {
+  let peerConnection = null;
+  let dataChannel = null;
+  let localStream = null;
+  let audioElement = null;
+
+  const state = {
+    status: 'idle',
+  };
+
+  function updateStatus(status) {
+    state.status = status;
+    onStatus(status);
+  }
+
+  function sendEvent(eventPayload) {
+    if (!dataChannel || dataChannel.readyState !== 'open') {
+      return;
+    }
+
+    dataChannel.send(JSON.stringify(eventPayload));
+  }
+
+  function configureSession() {
+    sendEvent({
+      type: 'session.update',
+      session: {
+        instructions,
+        output_modalities: ['audio'],
+        audio: {
+          output: {
+            voice,
+          },
+          input: {
+            turn_detection: {
+              type: 'semantic_vad',
+              create_response: true,
+              interrupt_response: true,
+            },
+          },
+        },
+      },
+    });
+  }
+
+  async function connect() {
+    if (peerConnection) {
+      return;
+    }
+
+    updateStatus('connecting');
+
+    try {
+      if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+        throw new Error('OpenAI Realtime requires a browser environment');
+      }
+
+      if (!navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+        throw new Error('Microphone access is not available in this browser');
+      }
+
+      const token = await resolveRealtimeKey(tokenEndpoint);
+
+      peerConnection = new RTCPeerConnection();
+      dataChannel = peerConnection.createDataChannel('oai-events');
+
+      dataChannel.addEventListener('message', (event) => {
+        try {
+          const payload = JSON.parse(event.data);
+          onEvent(payload);
+        } catch (error) {
+          onError(error);
+        }
+      });
+
+      dataChannel.addEventListener('open', () => {
+        configureSession();
+      });
+
+      localStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      localStream.getTracks().forEach((track) => peerConnection.addTrack(track, localStream));
+
+      audioElement = document.createElement('audio');
+      audioElement.autoplay = true;
+
+      peerConnection.addEventListener('track', (event) => {
+        const stream = event.streams?.[0];
+        if (stream && audioElement.srcObject !== stream) {
+          audioElement.srcObject = stream;
+        }
+      });
+
+      const offer = await peerConnection.createOffer();
+      await peerConnection.setLocalDescription(offer);
+
+      const response = await fetch(callsEndpoint, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${token}`,
+          'Content-Type': 'application/sdp',
+        },
+        body: offer.sdp,
+      });
+
+      if (!response.ok) {
+        throw new Error(`OpenAI Realtime SDP exchange failed with status ${response.status}`);
+      }
+
+      const answer = await response.text();
+      await peerConnection.setRemoteDescription({ type: 'answer', sdp: answer });
+
+      updateStatus('connected');
+    } catch (error) {
+      updateStatus('error');
+      onError(error);
+      disconnect();
+      throw error;
+    }
+  }
+
+  function disconnect() {
+    updateStatus('idle');
+
+    if (dataChannel) {
+      dataChannel.close();
+      dataChannel = null;
+    }
+
+    if (peerConnection) {
+      peerConnection.close();
+      peerConnection = null;
+    }
+
+    if (localStream) {
+      localStream.getTracks().forEach((track) => track.stop());
+      localStream = null;
+    }
+
+    if (audioElement) {
+      audioElement.srcObject = null;
+      audioElement = null;
+    }
+  }
+
+  function sendText(text) {
+    if (!text) {
+      return;
+    }
+
+    sendEvent({
+      type: 'conversation.item.create',
+      item: {
+        type: 'message',
+        role: 'user',
+        content: [{ type: 'input_text', text }],
+      },
+    });
+
+    sendEvent({ type: 'response.create' });
+  }
+
+  return {
+    connect,
+    disconnect,
+    sendText,
+    sendEvent,
+    get status() {
+      return state.status;
+    },
+  };
+}