@keyframelabs/elements 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,60 +1,60 @@
-import { createClient as f } from "@keyframelabs/sdk";
-const l = 24e3;
-function g(i) {
-  const e = atob(i), t = new Uint8Array(e.length);
-  for (let s = 0; s < e.length; s++)
-    t[s] = e.charCodeAt(s);
+import { createClient as _ } from "@keyframelabs/sdk";
+const u = 24e3;
+function f(s) {
+  const e = atob(s), t = new Uint8Array(e.length);
+  for (let n = 0; n < e.length; n++)
+    t[n] = e.charCodeAt(n);
   return t;
 }
-function m(i) {
+function S(s) {
   let e = "";
-  for (let t = 0; t < i.length; t++)
-    e += String.fromCharCode(i[t]);
+  for (let t = 0; t < s.length; t++)
+    e += String.fromCharCode(s[t]);
   return btoa(e);
 }
-function h(i, e, t) {
+function p(s, e, t) {
   if (e === t)
-    return i;
-  const s = new Int16Array(i.buffer, i.byteOffset, i.length / 2), n = e / t, a = Math.floor(s.length / n), d = new Int16Array(a);
-  for (let o = 0; o < a; o++) {
-    const S = o * n, p = Math.floor(S), b = Math.min(p + 1, s.length - 1), v = S - p;
-    d[o] = Math.round(
-      s[p] * (1 - v) + s[b] * v
+    return s;
+  const n = new Int16Array(s.buffer, s.byteOffset, s.length / 2), a = e / t, i = Math.floor(n.length / a), c = new Int16Array(i);
+  for (let l = 0; l < i; l++) {
+    const m = l * a, d = Math.floor(m), w = Math.min(d + 1, n.length - 1), g = m - d;
+    c[l] = Math.round(
+      n[d] * (1 - g) + n[w] * g
     );
   }
-  return new Uint8Array(d.buffer);
+  return new Uint8Array(c.buffer);
 }
-function E() {
-  const i = /* @__PURE__ */ new Map();
+function C() {
+  const s = /* @__PURE__ */ new Map();
   return {
     on(e, t) {
-      i.has(e) || i.set(e, /* @__PURE__ */ new Set()), i.get(e).add(t);
+      s.has(e) || s.set(e, /* @__PURE__ */ new Set()), s.get(e).add(t);
     },
     off(e, t) {
-      i.get(e)?.delete(t);
+      s.get(e)?.delete(t);
     },
     emit(e, t) {
-      i.get(e)?.forEach((s) => s(t));
+      s.get(e)?.forEach((n) => n(t));
     },
     removeAllListeners() {
-      i.clear();
+      s.clear();
     }
   };
 }
-function w(i) {
-  const e = new Int16Array(i.length);
-  for (let t = 0; t < i.length; t++) {
-    const s = Math.max(-1, Math.min(1, i[t]));
-    e[t] = s < 0 ? s * 32768 : s * 32767;
+function v(s) {
+  const e = new Int16Array(s.length);
+  for (let t = 0; t < s.length; t++) {
+    const n = Math.max(-1, Math.min(1, s[t]));
+    e[t] = n < 0 ? n * 32768 : n * 32767;
   }
   return new Uint8Array(e.buffer);
 }
-const C = 16e3;
-class u {
+const E = 16e3;
+class y {
   ws = null;
   _state = "idle";
-  events = E();
-  inputSampleRate = C;
+  events = C();
+  inputSampleRate = E;
   /** Current agent state */
   get state() {
     return this._state;
@@ -113,84 +113,8 @@ class u {
     this.events.emit("closed", { code: e, reason: t });
   }
 }
-const A = "gemini-2.5-flash-native-audio-preview-12-2025", I = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent", k = "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1alpha.GenerativeService.BidiGenerateContentConstrained";
-class R extends u {
-  agentName = "GeminiLive";
-  async connect(e) {
-    if (this.ws)
-      throw new Error("Already connected");
-    if (!e.apiKey)
-      throw new Error("Gemini API key is required");
-    e.inputSampleRate && (this.inputSampleRate = e.inputSampleRate);
-    const t = e.model ?? A, n = (e.authType ?? "api_key") === "ephemeral_token" ? `${k}?access_token=${encodeURIComponent(e.apiKey)}` : `${I}?key=${encodeURIComponent(e.apiKey)}`;
-    return new Promise((a, d) => {
-      this.ws = new WebSocket(n), this.ws.onopen = () => {
-        const o = {
-          setup: {
-            model: `models/${t}`,
-            generationConfig: {
-              responseModalities: ["AUDIO"]
-            },
-            systemInstruction: e.systemPrompt ? { parts: [{ text: e.systemPrompt }] } : void 0
-          }
-        };
-        this.ws.send(JSON.stringify(o)), this.setState("listening"), a();
-      }, this.ws.onerror = () => {
-        d(new Error("Failed to connect to Gemini Live"));
-      }, this.ws.onclose = (o) => {
-        this.ws = null, this.setState("idle"), this.emitClosed(o.code, o.reason);
-      }, this.ws.onmessage = (o) => {
-        this.handleMessage(o.data);
-      };
-    });
-  }
-  handleParsedMessage(e) {
-    const s = e.serverContent;
-    if (s) {
-      if (s.interrupted) {
-        this.events.emit("interrupted", void 0), this.setState("listening");
-        return;
-      }
-      if (s.turnComplete) {
-        this.events.emit("turnEnd", void 0), this.setState("listening");
-        return;
-      }
-      if (s.modelTurn?.parts) {
-        this._state !== "speaking" && (this.events.emit("turnStart", void 0), this.setState("speaking"));
-        for (const n of s.modelTurn.parts) {
-          if (n.inlineData?.data) {
-            const a = g(n.inlineData.data);
-            this.events.emit("audio", a);
-          }
-          n.text && this.events.emit("transcript", {
-            role: "assistant",
-            text: n.text,
-            isFinal: !0
-          });
-        }
-      }
-    }
-  }
-  sendAudio(e) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      console.warn("[GeminiLive] Cannot send audio: not connected");
-      return;
-    }
-    const t = {
-      realtimeInput: {
-        mediaChunks: [
-          {
-            mimeType: `audio/pcm;rate=${this.inputSampleRate}`,
-            data: m(e)
-          }
-        ]
-      }
-    };
-    this.ws.send(JSON.stringify(t));
-  }
-}
-const M = ["neutral", "angry", "sad", "happy"], T = "wss://api.elevenlabs.io/v1/convai/conversation";
-class _ extends u {
+const A = ["neutral", "angry", "sad", "happy"], I = "wss://api.elevenlabs.io/v1/convai/conversation";
+class R extends y {
   agentName = "ElevenLabs";
   outputSampleRate = 24e3;
   // Default, updated from metadata
@@ -202,6 +126,12 @@ class _ extends u {
   // True after conversation_initiation_metadata received
   lastInterruptId = 0;
   // Track interruptions to filter stale audio
+  // Virtual buffer turn-end detection: track audio duration and emit turnEnd
+  // when agent_response has arrived and all audio "would have" finished playing.
+  agentResponseReceived = !1;
+  turnStartTime = 0;
+  accumulatedDurationMs = 0;
+  turnEndTimer = null;
   async connect(e) {
     if (this.ws)
       throw new Error("Already connected");
@@ -209,15 +139,15 @@ class _ extends u {
       throw new Error("ElevenLabs agent ID or signed URL is required");
     e.inputSampleRate && (this.sourceInputSampleRate = e.inputSampleRate);
     let t;
-    return e.signedUrl ? t = e.signedUrl : (t = `${T}?agent_id=${e.agentId}`, e.apiKey && (t += `&xi-api-key=${e.apiKey}`)), new Promise((s, n) => {
+    return e.signedUrl ? t = e.signedUrl : (t = `${I}?agent_id=${e.agentId}`, e.apiKey && (t += `&xi-api-key=${e.apiKey}`)), new Promise((n, a) => {
       this.ws = new WebSocket(t), this.ws.onopen = () => {
-        this.setState("listening"), s();
+        this.setState("listening"), n();
       }, this.ws.onerror = () => {
-        n(new Error("Failed to connect to ElevenLabs"));
-      }, this.ws.onclose = (a) => {
-        this.ws = null, this.setState("idle"), this.emitClosed(a.code, a.reason);
-      }, this.ws.onmessage = (a) => {
-        this.handleMessage(a.data);
+        a(new Error("Failed to connect to ElevenLabs"));
+      }, this.ws.onclose = (i) => {
+        this.ws = null, this.setState("idle"), this.emitClosed(i.code, i.reason);
+      }, this.ws.onmessage = (i) => {
+        this.handleMessage(i.data);
       };
     });
   }
@@ -254,12 +184,12 @@ class _ extends u {
     const t = e.conversation_initiation_metadata_event;
     if (t) {
       if (t.agent_output_audio_format) {
-        const s = t.agent_output_audio_format.match(/pcm_(\d+)/);
-        s && (this.outputSampleRate = parseInt(s[1], 10));
+        const n = t.agent_output_audio_format.match(/pcm_(\d+)/);
+        n && (this.outputSampleRate = parseInt(n[1], 10));
       }
       if (t.user_input_audio_format) {
-        const s = t.user_input_audio_format.match(/pcm_(\d+)/);
-        s && (this.expectedInputSampleRate = parseInt(s[1], 10));
+        const n = t.user_input_audio_format.match(/pcm_(\d+)/);
+        n && (this.expectedInputSampleRate = parseInt(n[1], 10));
       }
       this.initialized = !0;
     }
@@ -275,8 +205,12 @@ class _ extends u {
     if (!t?.audio_base_64 || (t.event_id ?? 0) <= this.lastInterruptId)
       return;
     this._state !== "speaking" && (this.events.emit("turnStart", void 0), this.setState("speaking"));
-    let n = g(t.audio_base_64);
-    this.outputSampleRate !== l && (n = h(n, this.outputSampleRate, l)), this.events.emit("audio", n);
+    let a = f(t.audio_base_64);
+    this.outputSampleRate !== u && (a = p(a, this.outputSampleRate, u)), this.events.emit("audio", a);
+    const i = a.length / 2 / u * 1e3;
+    this.turnStartTime === 0 && (this.turnStartTime = Date.now()), this.accumulatedDurationMs += i, console.debug(
+      `[ElevenLabs] audio chunk: ${a.length} bytes, +${i.toFixed(0)}ms, totalDuration=${this.accumulatedDurationMs.toFixed(0)}ms, agentResponse=${this.agentResponseReceived}`
+    ), this.scheduleVirtualBufferCheck();
   }
   handleUserTranscript(e) {
     const t = e.user_transcription_event;
@@ -288,18 +222,38 @@ class _ extends u {
   }
   handleAgentResponse(e) {
     const t = e.agent_response_event;
-    t?.agent_response && (this.events.emit("turnEnd", void 0), this.setState("listening"), this.events.emit("transcript", {
+    t?.agent_response && (this.events.emit("transcript", {
       role: "assistant",
       text: t.agent_response,
       isFinal: !0
-    }));
+    }), this.agentResponseReceived = !0, console.debug(
+      `[ElevenLabs] agent_response received: totalDuration=${this.accumulatedDurationMs.toFixed(0)}ms, text="${t.agent_response.slice(0, 60)}${t.agent_response.length > 60 ? "..." : ""}"`
+    ), this.scheduleVirtualBufferCheck());
+  }
+  /**
+   * Schedule a timer to emit turnEnd when the virtual audio buffer
+   * "would have" finished playing. Replicates the ElevenLabs SDK's
+   * AudioWorklet buffer-empty detection without requiring local playback.
+   */
+  scheduleVirtualBufferCheck() {
+    if (!this.agentResponseReceived || this.turnStartTime === 0) return;
+    this.turnEndTimer !== null && clearTimeout(this.turnEndTimer);
+    const e = Date.now() - this.turnStartTime, t = Math.max(0, this.accumulatedDurationMs - e);
+    console.debug(
+      `[ElevenLabs] virtual buffer: elapsed=${e.toFixed(0)}ms, accumulated=${this.accumulatedDurationMs.toFixed(0)}ms, remaining=${t.toFixed(0)}ms`
+    ), this.turnEndTimer = setTimeout(() => {
+      this.turnEndTimer = null, console.debug("[ElevenLabs] virtual buffer drained, emitting turnEnd"), this.resetTurnState(), this.events.emit("turnEnd", void 0), this.setState("listening");
+    }, t);
+  }
+  resetTurnState() {
+    this.agentResponseReceived = !1, this.turnStartTime = 0, this.accumulatedDurationMs = 0, this.turnEndTimer !== null && (clearTimeout(this.turnEndTimer), this.turnEndTimer = null);
   }
   handleClientToolCall(e) {
     const t = e.client_tool_call;
     if (t) {
       if (t.tool_name === "set_emotion") {
-        const s = t.parameters?.emotion?.toLowerCase();
-        s && M.includes(s) && this.events.emit("emotion", s);
+        const n = t.parameters?.emotion?.toLowerCase();
+        n && A.includes(n) && this.events.emit("emotion", n);
       }
       this.ws && this.ws.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify({
         type: "client_tool_result",
@@ -311,14 +265,16 @@ class _ extends u {
   }
   handleInterruption(e) {
     const t = e.interruption_event;
-    t?.event_id && (this.lastInterruptId = t.event_id), this.events.emit("interrupted", void 0), this.setState("listening");
+    t?.event_id && (this.lastInterruptId = t.event_id), (this.agentResponseReceived || this.accumulatedDurationMs > 0) && console.debug(
+      `[ElevenLabs] interruption: discarding pending turn (duration=${this.accumulatedDurationMs.toFixed(0)}ms, agentResponse=${this.agentResponseReceived})`
+    ), this.resetTurnState(), this.events.emit("interrupted", void 0), this.setState("listening");
   }
   sendAudio(e) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.initialized)
       return;
     let t = e;
-    this.sourceInputSampleRate !== this.expectedInputSampleRate && (t = h(e, this.sourceInputSampleRate, this.expectedInputSampleRate)), this.ws.send(JSON.stringify({
-      user_audio_chunk: m(t)
+    this.sourceInputSampleRate !== this.expectedInputSampleRate && (t = p(e, this.sourceInputSampleRate, this.expectedInputSampleRate)), this.ws.send(JSON.stringify({
+      user_audio_chunk: S(t)
     }));
   }
   /**
@@ -348,217 +304,256 @@ class _ extends u {
     }));
   }
   close() {
-    this.initialized = !1, this.lastInterruptId = 0, super.close();
+    this.initialized = !1, this.lastInterruptId = 0, this.resetTurnState(), super.close();
   }
 }
-const P = "wss://api.cartesia.ai/agents/stream", x = "2025-04-16";
-class O extends u {
-  agentName = "Cartesia";
-  // Audio configuration
-  cartesiaInputFormat = "pcm_16000";
-  // Format we tell Cartesia we are sending
-  cartesiaOutputRate = 16e3;
-  // Cartesia defaults to 16kHz for web
-  // Connection state
-  streamId = null;
-  isReady = !1;
-  pingInterval = null;
+const T = ["neutral", "angry", "sad", "happy"], k = "wss://api.openai.com/v1/realtime", M = "gpt-realtime", h = 24e3, O = {
+  type: "function",
+  name: "set_emotion",
+  description: "Set the emotional expression of the avatar. Call this on every turn to reflect the tone of your response.",
+  parameters: {
+    type: "object",
+    properties: {
+      emotion: {
+        type: "string",
+        enum: ["neutral", "angry", "sad", "happy"],
+        description: "The emotion to display"
+      }
+    },
+    required: ["emotion"]
+  }
+};
+class P extends y {
+  agentName = "OpenAIRealtime";
+  connectResolve = null;
+  connectReject = null;
+  connectTimeout = null;
+  initialSessionUpdate = null;
+  currentResponseHasAudio = !1;
+  currentTranscript = "";
+  handledFunctionCallIds = /* @__PURE__ */ new Set();
+  sourceInputSampleRate = 16e3;
+  pendingFunctionCallStartedAtMs = null;
+  pendingFunctionCallNames = [];
   async connect(e) {
     if (this.ws)
       throw new Error("Already connected");
-    if (!e.agentId)
-      throw new Error("Cartesia Agent ID is required");
     if (!e.apiKey)
-      throw new Error("Cartesia API Key is required");
-    e.inputSampleRate && (this.inputSampleRate = e.inputSampleRate), this.inputSampleRate === 16e3 ? this.cartesiaInputFormat = "pcm_16000" : this.inputSampleRate === 24e3 ? this.cartesiaInputFormat = "pcm_24000" : this.inputSampleRate === 44100 ? this.cartesiaInputFormat = "pcm_44100" : this.cartesiaInputFormat = "pcm_16000";
-    const t = `${P}/${e.agentId}?api_key=${e.apiKey}&cartesia_version=${x}`;
-    return new Promise((s, n) => {
-      this.ws = new WebSocket(t), this.ws.onopen = () => {
-        this.sendStartEvent(), this.startHeartbeat(), s();
+      throw new Error("OpenAI Realtime token is required");
+    e.inputSampleRate && (this.sourceInputSampleRate = e.inputSampleRate);
+    const t = e.model ?? M;
+    return this.initialSessionUpdate = this.buildSessionUpdate(e, t), new Promise((n, a) => {
+      this.connectResolve = n, this.connectReject = a, this.connectTimeout = setTimeout(() => {
+        this.rejectPendingConnect(new Error("Timed out waiting for OpenAI Realtime session setup")), this.close();
+      }, 1e4), this.ws = new WebSocket(
+        `${k}?model=${encodeURIComponent(t)}`,
+        ["realtime", `openai-insecure-api-key.${e.apiKey}`]
+      ), this.ws.onopen = () => {
       }, this.ws.onerror = () => {
-        n(new Error("Failed to connect to Cartesia"));
-      }, this.ws.onclose = (a) => {
-        this.stopHeartbeat(), this.ws = null, this.isReady = !1, this.streamId = null, this.setState("idle"), this.emitClosed(a.code, a.reason);
-      }, this.ws.onmessage = (a) => {
-        this.handleMessage(a.data);
+        this.rejectPendingConnect(new Error("Failed to connect to OpenAI Realtime"));
+      }, this.ws.onclose = (i) => {
+        if (this.clearConnectTimeout(), this.connectReject) {
+          const c = i.reason ? `: ${i.reason}` : "";
+          this.rejectPendingConnect(new Error(`OpenAI Realtime closed before initialization (${i.code}${c})`));
+        }
+        this.resetTurnState(), this.initialSessionUpdate = null, this.ws = null, this.setState("idle"), this.emitClosed(i.code, i.reason);
+      }, this.ws.onmessage = (i) => {
+        this.handleMessage(i.data);
       };
     });
   }
-  sendStartEvent() {
-    if (!this.ws) return;
-    const e = {
-      event: "start",
-      config: {
-        input_format: this.cartesiaInputFormat
-      }
-    };
-    this.ws.send(JSON.stringify(e));
-  }
-  /**
-   * Keep connection alive with periodic custom events.
-   * Cartesia requires activity every 30s.
-   */
-  startHeartbeat() {
-    this.pingInterval = window.setInterval(() => {
-      this.ws?.readyState === WebSocket.OPEN && this.streamId && this.ws.send(JSON.stringify({
-        event: "custom",
-        stream_id: this.streamId,
-        metadata: { keepalive: !0 }
-      }));
-    }, 2e4);
-  }
-  stopHeartbeat() {
-    this.pingInterval && (clearInterval(this.pingInterval), this.pingInterval = null);
-  }
   handleParsedMessage(e) {
     const t = e;
-    switch (t.event) {
-      case "ack":
-        this.handleAck(t);
+    switch (t.type) {
+      case "session.created":
+        this.sendInitialSessionUpdate();
         break;
-      case "media_output":
-        this.handleMediaOutput(t);
+      case "session.updated":
+        this.clearConnectTimeout(), this.setState("listening"), this.resolvePendingConnect();
         break;
-      case "clear":
-        this.handleClear();
+      case "response.output_audio.delta":
+      case "response.audio.delta":
+        if (!t.delta)
+          return;
+        if (!this.currentResponseHasAudio) {
+          if (this.pendingFunctionCallStartedAtMs !== null) {
+            const n = performance.now() - this.pendingFunctionCallStartedAtMs;
+            console.debug("[OpenAIRealtime] Function call latency", {
+              calls: this.pendingFunctionCallNames,
+              latencyMs: Math.round(n)
+            }), this.pendingFunctionCallStartedAtMs = null, this.pendingFunctionCallNames = [];
+          }
+          this.currentResponseHasAudio = !0, this.events.emit("turnStart", void 0), this.setState("speaking");
+        }
+        this.events.emit("audio", f(t.delta));
+        break;
+      case "response.output_audio_transcript.delta":
+        if (!t.delta)
+          return;
+        this.currentTranscript += t.delta, this.events.emit("transcript", {
+          role: "assistant",
+          text: this.currentTranscript,
+          isFinal: !1
+        });
+        break;
+      case "response.output_audio_transcript.done":
+        if (!t.transcript)
+          return;
+        this.currentTranscript = t.transcript, this.events.emit("transcript", {
+          role: "assistant",
+          text: t.transcript,
+          isFinal: !0
+        });
+        break;
+      case "input_audio_buffer.speech_started":
+        this.resetTurnState(), this.events.emit("interrupted", void 0), this.setState("listening");
         break;
-      case "error":
-        console.error("[Cartesia] Server error:", t);
+      case "response.done":
+        this.handleResponseDone(t.response);
         break;
+      case "error": {
+        const n = t.error?.message ?? t.message ?? "Unknown OpenAI Realtime error";
+        this.rejectPendingConnect(new Error(n)), console.error("[OpenAIRealtime] Server error:", t);
+        break;
+      }
     }
   }
-  handleAck(e) {
-    this.streamId = e.stream_id || null, this.isReady = !0, this.setState("listening");
-  }
-  handleMediaOutput(e) {
-    if (!e.media?.payload) return;
-    this._state !== "speaking" && (this.events.emit("turnStart", void 0), this.setState("speaking"));
-    let t = g(e.media.payload);
-    this.cartesiaOutputRate !== l && (t = h(t, this.cartesiaOutputRate, l)), this.events.emit("audio", t);
-  }
-  handleClear() {
-    this.events.emit("interrupted", void 0), this.setState("listening");
-  }
   sendAudio(e) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || !this.isReady || !this.streamId)
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      console.warn("[OpenAIRealtime] Cannot send audio: not connected");
       return;
+    }
     let t = e;
-    const s = parseInt(this.cartesiaInputFormat.split("_")[1]);
-    this.inputSampleRate !== s && (t = h(e, this.inputSampleRate, s)), this.ws.send(JSON.stringify({
-      event: "media_input",
-      stream_id: this.streamId,
-      media: {
-        payload: m(t)
-      }
+    this.sourceInputSampleRate !== h && (t = p(e, this.sourceInputSampleRate, h)), this.ws.send(JSON.stringify({
+      type: "input_audio_buffer.append",
+      audio: S(t)
     }));
   }
   close() {
-    this.stopHeartbeat(), this.isReady = !1, this.streamId = null, super.close();
+    this.rejectPendingConnect(new Error("Connection closed")), this.clearConnectTimeout(), this.resetTurnState(), this.initialSessionUpdate = null, this.handledFunctionCallIds.clear(), super.close();
+  }
+  buildSessionUpdate(e, t) {
+    const n = e.turnDetection ?? { type: "semantic_vad", eagerness: "high" };
+    return {
+      type: "session.update",
+      session: {
+        type: "realtime",
+        model: t,
+        output_modalities: ["audio"],
+        instructions: e.systemPrompt,
+        audio: {
+          input: {
+            format: {
+              type: "audio/pcm",
+              rate: h
+            },
+            turn_detection: n
+          },
+          output: {
+            format: {
+              type: "audio/pcm",
+              rate: u
+            },
+            ...e.voice ? { voice: e.voice } : {}
+          }
+        },
+        tools: [O],
+        tool_choice: "auto"
+      }
+    };
   }
-}
-class N extends u {
-  agentName = "Vapi";
-  // Audio configuration - Vapi uses 16kHz PCM by default
-  vapiSampleRate = 16e3;
-  async connect(e) {
-    if (this.ws)
-      throw new Error("Already connected");
-    if (!e.signedUrl)
-      throw new Error("Vapi signed URL is required");
-    return e.inputSampleRate && (this.inputSampleRate = e.inputSampleRate), new Promise((t, s) => {
-      this.ws = new WebSocket(e.signedUrl), this.ws.binaryType = "arraybuffer", this.ws.onopen = () => {
-        this.setState("listening"), t();
-      }, this.ws.onerror = () => {
-        s(new Error("Failed to connect to Vapi"));
-      }, this.ws.onclose = (n) => {
-        this.ws = null, this.setState("idle"), this.emitClosed(n.code, n.reason);
-      }, this.ws.onmessage = (n) => {
-        n.data instanceof ArrayBuffer ? this.handleBinaryAudio(n.data) : this.handleMessage(n.data);
-      };
-    });
+  sendInitialSessionUpdate() {
+    this.initialSessionUpdate && this.sendEvent(this.initialSessionUpdate);
   }
-  /**
-   * Handle binary audio data from Vapi.
-   * Vapi sends raw PCM 16-bit little-endian audio.
-   */
-  handleBinaryAudio(e) {
-    this._state !== "speaking" && (this.events.emit("turnStart", void 0), this.setState("speaking"));
-    const t = new Uint8Array(e), s = this.vapiSampleRate !== l ? h(t, this.vapiSampleRate, l) : t;
-    this.events.emit("audio", s);
+  handleResponseDone(e) {
+    if (!e?.output?.length) {
+      this.currentResponseHasAudio && this.finishAudioTurn();
+      return;
+    }
+    const t = e.output.filter(x);
+    if (t.length > 0) {
+      this.handleFunctionCalls(t);
+      return;
+    }
+    this.currentResponseHasAudio && this.finishAudioTurn();
+  }
+  handleFunctionCalls(e) {
+    let t = !1;
+    const n = [];
+    for (const a of e) {
+      if (!a.call_id || this.handledFunctionCallIds.has(a.call_id))
+        continue;
+      this.handledFunctionCallIds.add(a.call_id), n.push(a.name ?? "unknown");
+      const i = this.handleFunctionCall(a);
+      this.sendEvent({
+        type: "conversation.item.create",
+        item: {
+          type: "function_call_output",
+          call_id: a.call_id,
+          output: JSON.stringify(i)
+        }
+      }), t = !0;
+    }
+    t && (this.pendingFunctionCallStartedAtMs = performance.now(), this.pendingFunctionCallNames = n, console.debug("[OpenAIRealtime] Function call received", {
+      calls: n
+    }), this.sendEvent({ type: "response.create" }));
   }
-  handleParsedMessage(e) {
-    const t = e;
-    switch (t.type) {
-      case "conversation-update":
-        t.role === "user" && t.transcript ? this.events.emit("transcript", {
-          role: "user",
-          text: t.transcript,
-          isFinal: !0
-        }) : t.role === "assistant" && t.transcript && this.events.emit("transcript", {
-          role: "assistant",
-          text: t.transcript,
-          isFinal: !0
-        });
-        break;
-      case "speech-update":
-        t.status === "started" ? (this.events.emit("turnStart", void 0), this.setState("speaking")) : t.status === "stopped" && (this.events.emit("turnEnd", void 0), this.setState("listening"));
-        break;
-      case "transcript":
-        this.events.emit("transcript", {
-          role: t.role === "user" ? "user" : "assistant",
-          text: t.transcript || "",
-          isFinal: t.transcriptType === "final"
-        });
-        break;
-      case "hang":
-      case "end-of-call-report":
-        this.events.emit("turnEnd", void 0), this.setState("idle");
-        break;
-      case "error":
-        console.error("[Vapi] Server error:", t);
-        break;
+  handleFunctionCall(e) {
+    if (e.name !== "set_emotion")
+      return { error: `Unsupported function: ${e.name}` };
+    try {
+      const n = (e.arguments ? JSON.parse(e.arguments) : {}).emotion?.toLowerCase();
+      return n && T.includes(n) ? (this.events.emit("emotion", n), { result: "ok" }) : { error: "Invalid emotion" };
+    } catch {
+      return { error: "Invalid function arguments" };
     }
   }
-  sendAudio(e) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+  finishAudioTurn() {
+    this.resetTurnState(), this.events.emit("turnEnd", void 0), this.setState("listening");
+  }
+  resetTurnState() {
+    this.currentResponseHasAudio = !1, this.currentTranscript = "";
+  }
+  sendEvent(e) {
+    !this.ws || this.ws.readyState !== WebSocket.OPEN || this.ws.send(JSON.stringify(e));
+  }
+  resolvePendingConnect() {
+    if (!this.connectResolve)
       return;
-    let t = e;
-    this.inputSampleRate !== this.vapiSampleRate && (t = h(e, this.inputSampleRate, this.vapiSampleRate)), this.ws.send(t.buffer);
+    const e = this.connectResolve;
+    this.connectResolve = null, this.connectReject = null, e();
   }
-  /**
-   * Send a control message to end the call.
-   */
-  hangup() {
-    this.ws && this.ws.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify({ type: "end-call" }));
+  rejectPendingConnect(e) {
+    if (!this.connectReject)
+      return;
+    const t = this.connectReject;
+    this.connectResolve = null, this.connectReject = null, t(e);
   }
-  close() {
-    this.hangup(), super.close();
+  clearConnectTimeout() {
+    this.connectTimeout !== null && (clearTimeout(this.connectTimeout), this.connectTimeout = null);
   }
 }
-const U = [
-  { id: "gemini", name: "Gemini Live", description: "Google Gemini Live API" },
+function x(s) {
+  return s.type === "function_call";
+}
+const D = [
   { id: "elevenlabs", name: "ElevenLabs", description: "ElevenLabs Conversational AI" },
-  { id: "cartesia", name: "Cartesia", description: "Cartesia Agents API" },
-  { id: "vapi", name: "Vapi", description: "Vapi WebSocket Transport" }
+  { id: "openai", name: "OpenAI Realtime", description: "OpenAI Realtime API" }
 ];
-function y(i) {
-  switch (i) {
-    case "gemini":
-      return new R();
+function b(s) {
+  switch (s) {
     case "elevenlabs":
-      return new _();
-    case "cartesia":
-      return new O();
-    case "vapi":
-      return new N();
+      return new R();
+    case "openai":
+      return new P();
     default:
-      throw new Error(`Unknown agent type: ${i}`);
+      throw new Error(`Unknown agent type: ${s}`);
   }
 }
-function F(i) {
-  return U.find((e) => e.id === i);
+function N(s) {
+  return D.find((e) => e.id === s);
 }
-class D extends Error {
+class F extends Error {
   status;
   payload;
   url;
@@ -566,8 +561,8 @@ class D extends Error {
     super(e.message), this.name = "ApiError", this.status = e.status, this.payload = e.payload, this.url = e.url;
   }
 }
-const r = /* @__PURE__ */ new Set();
-class K {
+const o = /* @__PURE__ */ new Set();
+class L {
   apiBaseUrl;
   publishableKey;
   callbacks;
@@ -611,31 +606,31 @@ class K {
   }
   /** Connect to the embed session */
   async connect() {
-    if (r.has(this.publishableKey)) {
+    if (o.has(this.publishableKey)) {
       console.log("[PersonaEmbed] Connection already in progress, skipping");
       return;
     }
-    r.add(this.publishableKey), this.mounted = !0, this.abortController = new AbortController(), this.setStatus("connecting");
+    o.add(this.publishableKey), this.mounted = !0, this.abortController = new AbortController(), this.setStatus("connecting");
     try {
       const e = await this.fetchSession(this.abortController.signal);
       if (!this.mounted) {
-        r.delete(this.publishableKey);
+        o.delete(this.publishableKey);
         return;
       }
       if (await this.initSession(e), await this.initMicrophone(), await this.connectAgent(e.voice_agent_details), !this.mounted) {
-        this.cleanup(), r.delete(this.publishableKey);
+        this.cleanup(), o.delete(this.publishableKey);
         return;
       }
       this.setStatus("connected");
     } catch (e) {
-      if (r.delete(this.publishableKey), e instanceof Error && e.name === "AbortError")
+      if (o.delete(this.publishableKey), e instanceof Error && e.name === "AbortError")
         return;
       console.error("[PersonaEmbed]", e), this.mounted && (this.setStatus("error"), this.callbacks.onError?.(e));
     }
   }
   /** Disconnect and cleanup */
   disconnect() {
-    this.mounted = !1, this.abortController?.abort(), this.abortController = null, r.delete(this.publishableKey), this.cleanup(), this.setStatus("disconnected");
+    this.mounted = !1, this.abortController?.abort(), this.abortController = null, o.delete(this.publishableKey), this.cleanup(), this.setStatus("disconnected");
   }
   /** Toggle microphone mute */
   toggleMute() {
@@ -655,31 +650,31 @@ class K {
       signal: e
     });
     if (!t.ok) {
-      let s;
+      let n;
       try {
-        s = await t.json();
+        n = await t.json();
       } catch {
       }
-      throw new D({
-        message: s?.message ?? "create_session failed",
+      throw new F({
+        message: n?.message ?? "create_session failed",
         status: t.status,
-        payload: s,
+        payload: n,
         url: t.url
       });
     }
     if (!t.ok) {
-      const s = await t.json().catch(() => null);
-      throw new Error(`create_session failed: ${t.status} ${JSON.stringify(s)}`);
+      const n = await t.json().catch(() => null);
+      throw new Error(`create_session failed: ${t.status} ${JSON.stringify(n)}`);
     }
     return t.json();
   }
   async initSession(e) {
-    this.session = f({
+    this.session = _({
       serverUrl: e.session_details.server_url,
       participantToken: e.session_details.participant_token,
       agentIdentity: e.session_details.agent_identity,
       onVideoTrack: (t) => {
-        console.log("[PersonaEmbed] Setting video track", t.readyState, t.enabled), this._video.srcObject = new MediaStream([t]), this._video.play().catch((s) => console.warn("[PersonaEmbed] Video play failed:", s));
+        console.log("[PersonaEmbed] Setting video track", t.readyState, t.enabled), this._video.srcObject = new MediaStream([t]), this._video.play().catch((n) => console.warn("[PersonaEmbed] Video play failed:", n));
       },
       onAudioTrack: (t) => {
         this._audio.srcObject = new MediaStream([t]), this._audio.play().catch(() => {
@@ -697,11 +692,11 @@ class K {
       onClose: () => {
         this.mounted && this.callbacks.onDisconnect?.();
       }
-    }), this.agent = y(e.voice_agent_details.type), this.agent.on("audio", (t) => this.session?.sendAudio(t)), this.agent.on("turnEnd", () => this.session?.endAudioTurn()), this.agent.on("interrupted", () => {
+    }), this.agent = b(e.voice_agent_details.type), this.agent.on("audio", (t) => this.session?.sendAudio(t)), this.agent.on("turnEnd", () => this.session?.endAudioTurn()), this.agent.on("interrupted", () => {
       this.session?.endAudioTurn(), this.session?.interrupt();
     }), this.agent.on("closed", () => {
       this.mounted && this.callbacks.onDisconnect?.();
-    }), this.agent instanceof _ && this.agent.on("emotion", (t) => this.session?.setEmotion(t)), await this.session.connect();
+    }), this.agent.on("emotion", (t) => this.session?.setEmotion(t)), await this.session.connect();
   }
   async initMicrophone() {
     this.stream = await navigator.mediaDevices.getUserMedia({
@@ -710,37 +705,32 @@ class K {
     const e = this.audioContext.createMediaStreamSource(this.stream);
     this.processor = this.audioContext.createScriptProcessor(4096, 1, 1), this.processor.onaudioprocess = (t) => {
       if (!this._isMuted) {
-        const s = w(t.inputBuffer.getChannelData(0));
-        this.agent?.sendAudio(s);
+        const n = v(t.inputBuffer.getChannelData(0));
+        this.agent?.sendAudio(n);
       }
     }, e.connect(this.processor), this.processor.connect(this.audioContext.destination);
   }
   async connectAgent(e) {
     if (!this.agent) return;
     const t = { inputSampleRate: 16e3 };
-    e.type === "gemini" ? await this.agent.connect({
-      ...t,
-      apiKey: e.token,
-      authType: "ephemeral_token"
-    }) : e.type === "elevenlabs" ? await this.agent.connect({
+    e.type === "elevenlabs" ? await this.agent.connect({
       ...t,
       agentId: e.agent_id,
       signedUrl: e.signed_url
-    }) : e.type === "cartesia" ? await this.agent.connect({
-      ...t,
-      agentId: e.agent_id,
-      apiKey: e.token
-    }) : e.type === "vapi" && await this.agent.connect({
+    }) : e.type === "openai" && await this.agent.connect({
       ...t,
-      signedUrl: e.signed_url
+      apiKey: e.token,
+      systemPrompt: e.system_prompt,
+      voice: e.voice,
+      turnDetection: e.turn_detection
     });
   }
   cleanup() {
     this.stream?.getTracks().forEach((e) => e.stop()), this.processor?.disconnect(), this.audioContext?.close(), this.agent?.close(), this.session?.close(), this.stream = null, this.processor = null, this.audioContext = null, this.agent = null, this.session = null;
   }
 }
-const c = /* @__PURE__ */ new Set();
-class B {
+const r = /* @__PURE__ */ new Set();
+class $ {
   voiceAgentDetails;
   sessionDetails;
   callbacks;
@@ -784,24 +774,24 @@ class B {
   }
   /** Connect to the session */
   async connect() {
-    if (c.has(this.connectionId)) {
+    if (r.has(this.connectionId)) {
       console.log("[PersonaView] Connection already in progress, skipping");
       return;
     }
-    c.add(this.connectionId), this.mounted = !0, this.setStatus("connecting");
+    r.add(this.connectionId), this.mounted = !0, this.setStatus("connecting");
     try {
       if (await this.initSession(), await this.initMicrophone(), await this.connectAgent(), !this.mounted) {
-        this.cleanup(), c.delete(this.connectionId);
+        this.cleanup(), r.delete(this.connectionId);
         return;
       }
       this.setStatus("connected");
     } catch (e) {
-      c.delete(this.connectionId), console.error("[PersonaView]", e), this.mounted && (this.setStatus("error"), this.callbacks.onError?.(e));
+      r.delete(this.connectionId), console.error("[PersonaView]", e), this.mounted && (this.setStatus("error"), this.callbacks.onError?.(e));
     }
   }
   /** Disconnect and cleanup */
   disconnect() {
-    this.mounted = !1, c.delete(this.connectionId), this.cleanup(), this.setStatus("disconnected");
+    this.mounted = !1, r.delete(this.connectionId), this.cleanup(), this.setStatus("disconnected");
   }
   /** Toggle microphone mute */
   toggleMute() {
@@ -814,7 +804,7 @@ class B {
     this._agentState !== e && (this._agentState = e, this.callbacks.onAgentStateChange?.(e));
   }
   async initSession() {
-    this.session = f({
+    this.session = _({
       serverUrl: this.sessionDetails.server_url,
       participantToken: this.sessionDetails.participant_token,
       agentIdentity: this.sessionDetails.agent_identity,
@@ -837,11 +827,11 @@ class B {
       onClose: () => {
         this.mounted && this.callbacks.onDisconnect?.();
       }
-    }), this.agent = y(this.voiceAgentDetails.type), this.agent.on("audio", (e) => this.session?.sendAudio(e)), this.agent.on("turnEnd", () => this.session?.endAudioTurn()), this.agent.on("interrupted", () => {
+    }), this.agent = b(this.voiceAgentDetails.type), this.agent.on("audio", (e) => this.session?.sendAudio(e)), this.agent.on("turnEnd", () => this.session?.endAudioTurn()), this.agent.on("interrupted", () => {
       this.session?.endAudioTurn(), this.session?.interrupt();
     }), this.agent.on("closed", () => {
       this.mounted && this.callbacks.onDisconnect?.();
-    }), this.agent instanceof _ && this.agent.on("emotion", (e) => this.session?.setEmotion(e)), await this.session.connect();
+    }), this.agent.on("emotion", (e) => this.session?.setEmotion(e)), await this.session.connect();
   }
   async initMicrophone() {
     this.stream = await navigator.mediaDevices.getUserMedia({
@@ -850,29 +840,24 @@ class B {
     const e = this.audioContext.createMediaStreamSource(this.stream);
     this.processor = this.audioContext.createScriptProcessor(4096, 1, 1), this.processor.onaudioprocess = (t) => {
       if (!this._isMuted) {
-        const s = w(t.inputBuffer.getChannelData(0));
-        this.agent?.sendAudio(s);
+        const n = v(t.inputBuffer.getChannelData(0));
+        this.agent?.sendAudio(n);
       }
     }, e.connect(this.processor), this.processor.connect(this.audioContext.destination);
   }
   async connectAgent() {
     if (!this.agent) return;
     const e = this.voiceAgentDetails, t = { inputSampleRate: 16e3 };
-    e.type === "gemini" ? await this.agent.connect({
-      ...t,
-      apiKey: e.token,
-      authType: "ephemeral_token"
-    }) : e.type === "elevenlabs" ? await this.agent.connect({
+    e.type === "elevenlabs" ? await this.agent.connect({
       ...t,
       agentId: e.agent_id,
       signedUrl: e.signed_url
-    }) : e.type === "cartesia" ? await this.agent.connect({
+    }) : e.type === "openai" && await this.agent.connect({
       ...t,
-      agentId: e.agent_id,
-      apiKey: e.token
-    }) : e.type === "vapi" && await this.agent.connect({
-      ...t,
-      signedUrl: e.signed_url
+      apiKey: e.token,
+      systemPrompt: e.system_prompt,
+      voice: e.voice,
+      turnDetection: e.turn_detection
     });
   }
   cleanup() {
@@ -880,20 +865,19 @@ class B {
   }
 }
 export {
-  U as AGENT_REGISTRY,
-  u as BaseAgent,
-  O as CartesiaAgent,
-  _ as ElevenLabsAgent,
-  R as GeminiLiveAgent,
-  D as KeyframeApiError,
-  K as PersonaEmbed,
-  B as PersonaView,
-  l as SAMPLE_RATE,
-  g as base64ToBytes,
-  m as bytesToBase64,
-  y as createAgent,
-  E as createEventEmitter,
-  w as floatTo16BitPCM,
-  F as getAgentInfo,
-  h as resamplePcm
+  D as AGENT_REGISTRY,
+  y as BaseAgent,
+  R as ElevenLabsAgent,
+  F as KeyframeApiError,
+  P as OpenAIRealtimeAgent,
+  L as PersonaEmbed,
+  $ as PersonaView,
+  u as SAMPLE_RATE,
+  f as base64ToBytes,
+  S as bytesToBase64,
+  b as createAgent,
+  C as createEventEmitter,
+  v as floatTo16BitPCM,
+  N as getAgentInfo,
+  p as resamplePcm
 };