@glydeunity/voice-sdk 1.0.0 → 1.2.0

package/dist/voice-sdk.es.js

@@ -1,4 +1,500 @@
-import { G as r } from "./index-BbD4w_Sz.js";
+const h = `
+class AudioCaptureProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.bufferSize = 4096;
+    this.buffer = new Float32Array(this.bufferSize);
+    this.bufferIndex = 0;
+  }
+
+  process(inputs) {
+    const input = inputs[0];
+    if (!input || !input[0]) return true;
+
+    const samples = input[0];
+    
+    for (let i = 0; i < samples.length; i++) {
+      this.buffer[this.bufferIndex++] = samples[i];
+      
+      if (this.bufferIndex >= this.bufferSize) {
+        const pcm16 = new Int16Array(this.bufferSize);
+        for (let j = 0; j < this.bufferSize; j++) {
+          const s = Math.max(-1, Math.min(1, this.buffer[j]));
+          pcm16[j] = s < 0 ? s * 0x8000 : s * 0x7FFF;
+        }
+        
+        this.port.postMessage(pcm16.buffer, [pcm16.buffer]);
+        this.bufferIndex = 0;
+      }
+    }
+
+    return true;
+  }
+}
+
+registerProcessor('audio-capture-processor', AudioCaptureProcessor);
+`, p = `
+class AudioPlaybackProcessor extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    
+    this.bufferSize = 48000 * 15;
+    this.buffer = new Float32Array(this.bufferSize);
+    this.writeIndex = 0;
+    this.readIndex = 0;
+    this.samplesAvailable = 0;
+    this.isPlaying = false;
+    
+    this.port.onmessage = (event) => {
+      const { type, data } = event.data;
+      
+      switch (type) {
+        case 'audio':
+          const audioData = data instanceof Float32Array ? data : new Float32Array(data);
+          this.writeAudio(audioData);
+          break;
+        case 'clear':
+          this.clearBuffer();
+          break;
+      }
+    };
+  }
+
+  writeAudio(samples) {
+    if (!samples || samples.length === 0) return;
+    
+    const samplesToWrite = samples.length;
+    
+    if (this.samplesAvailable + samplesToWrite > this.bufferSize) {
+      const overflow = (this.samplesAvailable + samplesToWrite) - this.bufferSize;
+      this.readIndex = (this.readIndex + overflow) % this.bufferSize;
+      this.samplesAvailable -= overflow;
+    }
+    
+    for (let i = 0; i < samplesToWrite; i++) {
+      this.buffer[this.writeIndex] = samples[i];
+      this.writeIndex = (this.writeIndex + 1) % this.bufferSize;
+    }
+    
+    this.samplesAvailable += samplesToWrite;
+    this.isPlaying = true;
+  }
+
+  clearBuffer() {
+    this.readIndex = 0;
+    this.writeIndex = 0;
+    this.samplesAvailable = 0;
+    this.isPlaying = false;
+    this.port.postMessage({ type: 'cleared' });
+  }
+
+  process(inputs, outputs) {
+    const output = outputs[0];
+    if (!output || !output[0]) return true;
+    
+    const outputChannel = output[0];
+    const samplesToRead = outputChannel.length;
+    
+    if (this.samplesAvailable >= samplesToRead) {
+      for (let i = 0; i < samplesToRead; i++) {
+        outputChannel[i] = this.buffer[this.readIndex];
+        this.readIndex = (this.readIndex + 1) % this.bufferSize;
+      }
+      this.samplesAvailable -= samplesToRead;
+    } else if (this.samplesAvailable > 0) {
+      let i = 0;
+      while (this.samplesAvailable > 0 && i < samplesToRead) {
+        outputChannel[i] = this.buffer[this.readIndex];
+        this.readIndex = (this.readIndex + 1) % this.bufferSize;
+        this.samplesAvailable--;
+        i++;
+      }
+      while (i < samplesToRead) {
+        outputChannel[i] = 0;
+        i++;
+      }
+      
+      if (this.isPlaying) {
+        this.isPlaying = false;
+        this.port.postMessage({ type: 'bufferEmpty' });
+      }
+    } else {
+      for (let i = 0; i < samplesToRead; i++) {
+        outputChannel[i] = 0;
+      }
+      this.isPlaying = false;
+    }
+    
+    return true;
+  }
+}
+
+registerProcessor('audio-playback-processor', AudioPlaybackProcessor);
+`;
+class u {
+  config;
+  unityUrl;
+  active = !1;
+  serverConfig = null;
+  // WebSocket and Audio
+  ws = null;
+  audioContext = null;
+  mediaStream = null;
+  captureWorkletNode = null;
+  playbackWorkletNode = null;
+  isMuted = !1;
+  // Audio settings
+  outputSampleRate = 24e3;
+  // Deepgram TTS output rate
+  inputSampleRate = 48e3;
+  // Microphone input rate
+  // Agent state
+  isAgentSpeaking = !1;
+  agentAudioDoneReceived = !1;
+  /**
+   * Create a new GlydeVoice instance
+   * @param config - Configuration options
+   */
+  constructor(e) {
+    this.config = e, this.unityUrl = e.unityBaseUrl || "https://api.glydeunity.com", !e.publishableKey && !e.apiKey && !e.authToken && console.warn("[GlydeVoice] No authentication method provided. One of publishableKey, apiKey, or authToken is required.");
+  }
+  /**
+   * Get authentication headers based on configured auth method
+   * Supports publishableKey, apiKey, and JWT token (authToken)
+   * @returns Headers object with appropriate authentication
+   */
+  getAuthHeaders() {
+    const e = {
+      "Content-Type": "application/json"
+    };
+    return this.config.publishableKey && (e["x-publishable-key"] = this.config.publishableKey), this.config.apiKey && (e["x-api-key"] = this.config.apiKey), this.config.authToken && (e.Authorization = `Bearer ${this.config.authToken}`), e;
+  }
+  /**
+   * Fetch voice configuration from Unity API
+   * @returns Voice configuration including system prompt, tools, and Deepgram settings
+   */
+  async fetchConfig() {
+    const e = `${this.unityUrl}/api/unity/voice/config/${this.config.contextType}`, t = this.config.contextId ? `${e}/${this.config.contextId}` : e, s = await fetch(t, {
+      method: "GET",
+      headers: this.getAuthHeaders()
+    });
+    if (!s.ok) {
+      const a = await s.json();
+      throw new Error(a.error?.message || a.message || "Failed to fetch voice config");
+    }
+    const { data: o } = await s.json();
+    return o;
+  }
+  /**
+   * Initialize and start the voice session
+   */
+  async start() {
+    if (!this.active) {
+      this.active = !0;
+      try {
+        this.config.systemPrompt || (this.serverConfig = await this.fetchConfig(), console.log("[GlydeVoice] Fetched config:", this.serverConfig));
+        const e = await fetch(`${this.unityUrl}/api/unity/voice/auth`, {
+          method: "POST",
+          headers: this.getAuthHeaders(),
+          body: JSON.stringify({
+            context_id: this.config.contextId,
+            domain: typeof window < "u" ? window.location.hostname : "localhost"
+          })
+        });
+        if (!e.ok) {
+          const i = await e.json();
+          throw new Error(i.error?.message || i.message || "Failed to authenticate voice session");
+        }
+        const { data: t } = await e.json(), { token: s, agent_config: o } = t, a = this.config.systemPrompt || this.serverConfig?.system_prompt || o.instructions || "You are a helpful AI assistant.";
+        await this.initializeAudio();
+        const r = "wss://agent.deepgram.com/v1/agent/converse";
+        this.ws = new WebSocket(r, ["bearer", s]), this.ws.onopen = () => {
+          const i = this.config.deepgramConfig || this.serverConfig?.deepgram_config || {
+            think: { provider: { type: "open_ai", model: "gpt-4o-mini" } },
+            speak: { provider: { type: "deepgram", model: "aura-2-thalia-en" } },
+            listen: { provider: { type: "deepgram", model: "nova-2", version: "latest" } }
+          }, n = {
+            type: "Settings",
+            audio: {
+              input: {
+                encoding: "linear16",
+                sample_rate: this.inputSampleRate
+              },
+              output: {
+                encoding: "linear16",
+                sample_rate: this.outputSampleRate,
+                container: "none"
+              }
+            },
+            agent: {
+              language: "en",
+              speak: i.speak || {
+                provider: { type: "deepgram", model: "aura-2-thalia-en" }
+              },
+              listen: i.listen || {
+                provider: { type: "deepgram", version: "v2", model: "flux-general-en" }
+              },
+              think: {
+                provider: i.think?.provider || { type: "open_ai", model: "gpt-4o-mini" },
+                functions: i.think?.functions || [
+                  {
+                    name: "end_conversation",
+                    description: "End the conversation when stop phrases are detected.",
+                    parameters: {
+                      type: "object",
+                      properties: {
+                        item: { type: "string", description: "The phrase that triggered end of conversation" }
+                      },
+                      required: ["item"]
+                    }
+                  }
+                ]
+              },
+              greeting: "Hi! I'm ready to speak with you. How can I help you today?"
+            }
+          };
+          this.ws.send(JSON.stringify(n)), this.emit({ type: "open", payload: { config: o, serverConfig: this.serverConfig } });
+        };
+        const l = a;
+        this.ws.onmessage = (i) => {
+          if (typeof i.data == "string") {
+            try {
+              if (JSON.parse(i.data).type === "SettingsApplied") {
+                const c = {
+                  type: "UpdatePrompt",
+                  prompt: l
+                };
+                this.ws.send(JSON.stringify(c)), this.startMicrophone();
+              }
+            } catch {
+            }
+            this.handleTextMessage(i.data);
+          } else i.data instanceof Blob ? this.handleAudioData(i.data) : i.data instanceof ArrayBuffer && this.handleAudioBuffer(i.data);
+        }, this.ws.onerror = (i) => {
+          console.error("[GlydeVoice] WebSocket error:", i), this.emit({ type: "error", payload: i });
+        }, this.ws.onclose = () => {
+          this.cleanup(), this.emit({ type: "close" });
+        }, this.renderUI();
+      } catch (e) {
+        throw console.error("[GlydeVoice] Error starting session:", e), this.active = !1, this.emit({ type: "error", payload: e }), e;
+      }
+    }
+  }
+  /**
+   * Create a blob URL from inline JavaScript code for AudioWorklet modules.
+   * This avoids CORS issues when the SDK is loaded from a different origin than the page.
+   * @param code - The JavaScript code to convert to a blob URL
+   * @returns A blob URL that can be used with audioWorklet.addModule()
+   */
+  createWorkletBlobUrl(e) {
+    const t = new Blob([e], { type: "application/javascript" });
+    return URL.createObjectURL(t);
+  }
+  /**
+   * Initialize the audio system with both capture and playback worklets.
+   * Uses inline blob URLs to avoid CORS issues when SDK is embedded in external apps.
+   */
+  async initializeAudio() {
+    this.audioContext = new AudioContext({ sampleRate: this.inputSampleRate });
+    const e = this.createWorkletBlobUrl(h), t = this.createWorkletBlobUrl(p);
+    try {
+      await Promise.all([
+        this.audioContext.audioWorklet.addModule(e),
+        this.audioContext.audioWorklet.addModule(t)
+      ]);
+    } finally {
+      URL.revokeObjectURL(e), URL.revokeObjectURL(t);
+    }
+    this.playbackWorkletNode = new AudioWorkletNode(this.audioContext, "audio-playback-processor"), this.playbackWorkletNode.connect(this.audioContext.destination), this.playbackWorkletNode.port.onmessage = (s) => {
+      const { type: o } = s.data;
+      (o === "cleared" || o === "bufferEmpty") && (this.isAgentSpeaking = !1, this.agentAudioDoneReceived = !1, this.emit({ type: "agent_speaking", payload: !1 }));
+    };
+  }
+  /**
+   * Handle text messages from the Voice Agent
+   */
+  handleTextMessage(e) {
+    try {
+      const t = JSON.parse(e);
+      switch (t.type) {
+        case "Welcome":
+          this.emit({ type: "ready" });
+          break;
+        case "SettingsApplied":
+          break;
+        case "UserStartedSpeaking":
+          this.emit({ type: "user_speaking", payload: !0 }), this.clearPlaybackBuffer(), this.isAgentSpeaking = !1, this.agentAudioDoneReceived = !1;
+          break;
+        case "UserStoppedSpeaking":
+          this.emit({ type: "user_speaking", payload: !1 });
+          break;
+        case "ConversationText":
+          if (t.content && t.content.trim()) {
+            const s = t.role === "assistant" ? "agent" : "user";
+            this.config.onTranscript && this.config.onTranscript(t.content, s), this.emit({ type: "transcript", payload: { text: t.content, role: s } }), this.saveTranscript(t.content, t.role);
+          }
+          break;
+        case "AgentStartedSpeaking":
+          this.isAgentSpeaking = !0, this.agentAudioDoneReceived = !1, this.emit({ type: "agent_speaking", payload: !0 });
+          break;
+        case "AgentAudioDone":
+          this.agentAudioDoneReceived = !0;
+          break;
+        case "Error":
+          console.error("[GlydeVoice] Agent error:", t), this.emit({ type: "error", payload: t });
+          break;
+      }
+    } catch (t) {
+      console.error("[GlydeVoice] Failed to parse message:", t);
+    }
+  }
+  /**
+   * Handle binary audio data (Blob) from agent TTS
+   */
+  async handleAudioData(e) {
+    const t = await e.arrayBuffer();
+    this.handleAudioBuffer(t);
+  }
+  /**
+   * Handle binary audio buffer from agent TTS
+   * Deepgram sends linear16 PCM at 24kHz, we need to resample to 48kHz for playback
+   */
+  handleAudioBuffer(e) {
+    if (!this.playbackWorkletNode || !this.audioContext) return;
+    this.audioContext.state === "suspended" && this.audioContext.resume();
+    const t = e.byteLength;
+    if (t === 0) return;
+    const s = t - t % 2;
+    if (s === 0) return;
+    const o = s === t ? e : e.slice(0, s), a = new Int16Array(o), r = new Float32Array(a.length);
+    for (let n = 0; n < a.length; n++)
+      r[n] = a[n] / 32768;
+    const l = this.resample24kTo48k(r);
+    !this.isAgentSpeaking && !this.agentAudioDoneReceived && (this.isAgentSpeaking = !0, this.emit({ type: "agent_speaking", payload: !0 }));
+    const i = new Float32Array(l);
+    this.playbackWorkletNode.port.postMessage({
+      type: "audio",
+      data: i
+    }, [i.buffer]);
+  }
+  /**
+   * Resample audio from 24kHz to 48kHz using linear interpolation
+   */
+  resample24kTo48k(e) {
+    const t = e.length * 2, s = new Float32Array(t);
+    for (let a = 0; a < e.length - 1; a++) {
+      const r = e[a], l = e[a + 1];
+      s[a * 2] = r, s[a * 2 + 1] = (r + l) / 2;
+    }
+    const o = e.length - 1;
+    return s[o * 2] = e[o], s[o * 2 + 1] = e[o], s;
+  }
+  /**
+   * Clear the playback buffer (for interruption handling)
+   */
+  clearPlaybackBuffer() {
+    this.playbackWorkletNode && this.playbackWorkletNode.port.postMessage({ type: "clear" });
+  }
+  /**
+   * Start capturing microphone audio using AudioWorklet
+   */
+  async startMicrophone() {
+    if (!this.audioContext)
+      throw new Error("Audio context not initialized");
+    try {
+      this.mediaStream = await navigator.mediaDevices.getUserMedia({
+        audio: {
+          channelCount: 1,
+          sampleRate: this.inputSampleRate,
+          echoCancellation: !0,
+          noiseSuppression: !0
+        }
+      });
+      const e = this.audioContext.createMediaStreamSource(this.mediaStream);
+      this.captureWorkletNode = new AudioWorkletNode(this.audioContext, "audio-capture-processor"), this.captureWorkletNode.port.onmessage = (t) => {
+        !this.active || !this.ws || this.ws.readyState !== WebSocket.OPEN || this.isMuted || this.ws.send(t.data);
+      }, e.connect(this.captureWorkletNode), this.emit({ type: "microphone_ready" });
+    } catch (e) {
+      throw console.error("[GlydeVoice] Microphone error:", e), e;
+    }
+  }
+  /**
+   * Save transcript to Unity backend
+   */
+  async saveTranscript(e, t) {
+    if (!(!this.config.contextId || !e))
+      try {
+        await fetch(`${this.unityUrl}/api/unity/voice/transcript`, {
+          method: "POST",
+          headers: this.getAuthHeaders(),
+          body: JSON.stringify({
+            context_id: this.config.contextId,
+            content: e,
+            role: t === "assistant" ? "assistant" : "user"
+          })
+        });
+      } catch {
+      }
+  }
+  /**
+   * Toggle mute state
+   * @param muted - Whether to mute the microphone
+   */
+  setMuted(e) {
+    this.isMuted = e;
+  }
+  /**
+   * Get current mute state
+   */
+  getMuted() {
+    return this.isMuted;
+  }
+  /**
+   * Check if the voice agent is currently active
+   */
+  isActive() {
+    return this.active;
+  }
+  /**
+   * Get the current server configuration
+   */
+  getServerConfig() {
+    return this.serverConfig;
+  }
+  /**
+   * Stop the voice session
+   */
+  stop() {
+    this.active = !1, this.cleanup();
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.captureWorkletNode && (this.captureWorkletNode.disconnect(), this.captureWorkletNode.port.close(), this.captureWorkletNode = null), this.playbackWorkletNode && (this.playbackWorkletNode.disconnect(), this.playbackWorkletNode.port.close(), this.playbackWorkletNode = null), this.mediaStream && (this.mediaStream.getTracks().forEach((e) => e.stop()), this.mediaStream = null), this.audioContext && (this.audioContext.close(), this.audioContext = null), this.ws && (this.ws.readyState === WebSocket.OPEN && this.ws.close(), this.ws = null);
+  }
+  /**
+   * Emit event to callback
+   */
+  emit(e) {
+    this.config.onEvent && this.config.onEvent(e);
+  }
+  /**
+   * Render a simple UI widget (optional)
+   */
+  renderUI() {
+    if (!this.config.container) return;
+    const e = typeof this.config.container == "string" ? document.querySelector(this.config.container) : this.config.container;
+    e && (e.innerHTML = `
+        <div style="padding: 20px; border: 1px solid #ccc; border-radius: 8px; background: #fff;">
+          <h3>Glyde Voice Agent</h3>
+          <p>Status: Active</p>
+          <p>Context: ${this.config.contextType}</p>
+          <button onclick="this.closest('div').remove()">Close</button>
+        </div>
+      `);
+  }
+}
 export {
-  r as GlydeVoice
+  u as GlydeVoice
 };