@vanira/sdk 0.0.42 → 0.0.43

package/dist/VaniraAI-D2KUxJJO.js

@@ -0,0 +1,682 @@
+var v = Object.defineProperty;
+var T = (g, e, t) => e in g ? v(g, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : g[e] = t;
+var a = (g, e, t) => T(g, typeof e != "symbol" ? e + "" : e, t);
+class b {
+  // private iceServers?: RTCIceServer[];
+  // private token?: string;
+  constructor(e) {
+    a(this, "serverUrl");
+    a(this, "agentId");
+    a(this, "callId");
+    a(this, "prospectId");
+    a(this, "apiKey");
+    a(this, "backendUrl");
+    a(this, "token");
+    a(this, "onConnected");
+    a(this, "onDisconnected");
+    a(this, "onError");
+    a(this, "onTranscription");
+    a(this, "onLocalStream");
+    // @ts-ignore
+    a(this, "onRemoteTrack");
+    a(this, "onClientToolCall");
+    a(this, "onSessionStarted");
+    a(this, "sessionStartedEmitted", !1);
+    a(this, "pc", null);
+    a(this, "dataChannel", null);
+    a(this, "audioElement", null);
+    a(this, "localStream", null);
+    a(this, "connected", !1);
+    if (!e.agentId) throw new Error("agentId is required");
+    if (!e.serverUrl && !e.apiKey) throw new Error("Provide either serverUrl or apiKey (to use createCall())");
+    this.agentId = e.agentId, this.serverUrl = e.serverUrl ? e.serverUrl.replace(/\/$/, "") : "", this.apiKey = e.apiKey, this.backendUrl = (e.backendUrl || "https://api.vanira.io").replace(/\/$/, "");
+    const t = typeof window < "u";
+    if (this.prospectId = e.prospectId, !this.prospectId && t)
+      try {
+        this.prospectId = window.sessionStorage && window.sessionStorage.getItem("vanira_prospect_id") || window.localStorage && window.localStorage.getItem("vanira_prospect_id") || void 0;
+      } catch {
+      }
+    const n = e.sessionBehavior === "continue";
+    if (e.callId)
+      this.callId = e.callId;
+    else if (n && t)
+      try {
+        this.callId = window.sessionStorage && window.sessionStorage.getItem("vanira_latest_call_id") || window.localStorage && window.localStorage.getItem("vanira_latest_call_id") || void 0;
+      } catch {
+      }
+    else
+      this.callId = void 0;
+    this.onConnected = e.onConnected || (() => {
+    }), this.onDisconnected = e.onDisconnected || (() => {
+    }), this.onError = e.onError || ((i) => console.error("[WebRTC]", i)), this.onTranscription = e.onTranscription || (() => {
+    }), this.onLocalStream = e.onLocalStream || (() => {
+    }), this.onRemoteTrack = e.onRemoteTrack || (() => {
+    }), this.onClientToolCall = e.onClientToolCall || (() => {
+    }), this.onSessionStarted = e.onSessionStarted;
+  }
+  /**
+   * Create a call session via the Vanira API, then connect.
+   * Requires apiKey in the constructor config.
+   * Equivalent to manually calling POST /calls/create + client.connect().
+   */
+  async createCall() {
+    var i;
+    if (!this.apiKey) throw new Error("[VaniraAI] apiKey is required to use createCall()");
+    const e = {
+      "Content-Type": "application/json",
+      "X-API-Key": this.apiKey
+    }, t = await fetch(`${this.backendUrl}/calls/create`, {
+      method: "POST",
+      headers: e,
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        type: "web",
+        prospect_id: this.prospectId,
+        call_id: this.callId
+      })
+    });
+    if (!t.ok) {
+      const r = await t.json().catch(() => ({}));
+      throw new Error(`[VaniraAI] createCall failed (${t.status}): ${((i = r == null ? void 0 : r.detail) == null ? void 0 : i.message) || (r == null ? void 0 : r.message) || t.statusText}`);
+    }
+    const n = await t.json();
+    if (!n.call_id || !n.worker_url)
+      throw new Error("[VaniraAI] createCall response missing call_id or worker_url");
+    if (this.callId = n.call_id, this.prospectId = n.prospect_id || this.prospectId, this.serverUrl = n.worker_url, typeof window < "u")
+      try {
+        window.sessionStorage && (window.sessionStorage.setItem("vanira_prospect_id", this.prospectId || ""), window.sessionStorage.setItem("vanira_latest_call_id", this.callId || "")), window.localStorage && (window.localStorage.setItem("vanira_prospect_id", this.prospectId || ""), window.localStorage.setItem("vanira_latest_call_id", this.callId || ""));
+      } catch (r) {
+        console.warn("[WebRTC] Failed to save session variables to storage:", r);
+      }
+    if (this.onSessionStarted && this.prospectId && this.callId)
+      try {
+        this.onSessionStarted({ prospectId: this.prospectId, callId: this.callId, serverUrl: this.serverUrl }), this.sessionStartedEmitted = !0;
+      } catch (r) {
+        console.error("[WebRTC] Error in onSessionStarted callback:", r);
+      }
+    await this.connect();
+  }
+  /**
+   * Connect to the agent. If apiKey is set and serverUrl is not yet resolved,
+   * automatically calls the pre-flight API to get call_id + worker_url first.
+   */
+  async connect() {
+    var e;
+    if (this.apiKey && !this.serverUrl) {
+      await this.createCall();
+      return;
+    }
+    if (!this.serverUrl) throw new Error("[VaniraAI] serverUrl is missing. Provide apiKey or serverUrl.");
+    if (this.callId || (this.callId = this.generateCallId()), this.onSessionStarted && this.prospectId && this.callId && !this.sessionStartedEmitted)
+      try {
+        this.onSessionStarted({ prospectId: this.prospectId, callId: this.callId, serverUrl: this.serverUrl }), this.sessionStartedEmitted = !0;
+      } catch (t) {
+        console.error("[WebRTC] Error in onSessionStarted callback:", t);
+      }
+    console.log("🔵 [WebRTC] Starting connection...");
+    try {
+      this.pc = new RTCPeerConnection({
+        iceServers: [
+          { urls: "stun:stun.l.google.com:19302" },
+          { urls: "stun:stun1.l.google.com:19302" },
+          { urls: "stun:global.relay.metered.ca:80" },
+          // works on Jio (port 80)
+          {
+            urls: [
+              "turns:global.relay.metered.ca:443?transport=tcp",
+              "turn:global.relay.metered.ca:443?transport=tcp",
+              "turn:global.relay.metered.ca:80?transport=tcp"
+            ],
+            username: "fa97658be3343d21da3b65e6",
+            credential: "HXHDoqeHbvZrmCuf"
+          }
+        ],
+        iceTransportPolicy: "all"
+        // P2P if possible, TURN only as fallback
+      }), console.log("using ice servers:", [
+        { urls: "stun:stun.l.google.com:19302" },
+        { urls: "stun:stun1.l.google.com:19302" }
+      ]);
+      let t;
+      try {
+        t = await navigator.mediaDevices.getUserMedia({
+          audio: {
+            echoCancellation: !0,
+            noiseSuppression: !0,
+            autoGainControl: !0,
+            sampleRate: { ideal: 16e3 },
+            channelCount: 1
+          }
+        });
+      } catch (o) {
+        if (console.error("🎤 [WebRTC] Microphone access failed:", o), o.name === "NotAllowedError" || o.name === "PermissionDeniedError" || (e = o.message) != null && e.includes("Permission denied")) {
+          const s = navigator.userAgent, c = /iPad|iPhone|iPod/.test(s) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+          let p = "Microphone access denied. Please allow microphone access in your browser settings.";
+          c && (s.includes("CriOS") ? p = "Microphone access blocked. Please enable it in iOS Settings > Chrome > Microphone, then reload the page." : s.includes("FxiOS") ? p = "Microphone access blocked. Please enable it in iOS Settings > Firefox > Microphone, then reload the page." : p = "Microphone access blocked. Please enable it in iOS Settings > Safari > Microphone (or tap 'aA' > Website Settings > Allow Microphone).");
+          const h = new Error(p);
+          throw h.name = o.name, h;
+        }
+        throw o;
+      }
+      if (console.log("🎤 [WebRTC] Microphone access granted"), this.localStream = t, !this.pc) {
+        console.log("[WebRTC] Connection aborted: peer connection closed during setup"), t.getTracks().forEach((o) => o.stop());
+        return;
+      }
+      if (this.onLocalStream(t), t.getTracks().forEach((o) => {
+        var s;
+        (s = this.pc) == null || s.addTrack(o, t);
+      }), !this.pc)
+        throw new Error("RTCPeerConnection was closed unexpectedly");
+      this.dataChannel = this.pc.createDataChannel("control"), this.dataChannel.onopen = () => console.log("📡 [WebRTC] DataChannel opened"), this.dataChannel.onmessage = (o) => {
+        if (typeof o.data == "string")
+          try {
+            this.handleControlEvent(JSON.parse(o.data));
+          } catch {
+            console.warn("[WebRTC] Failed to parse message:", o.data);
+          }
+        else if (o.data instanceof ArrayBuffer)
+          try {
+            const s = new TextDecoder().decode(o.data);
+            try {
+              const c = JSON.parse(s);
+              c && typeof c == "object" && c.event === "client_tool_call" ? (console.log("[VaniraAI] Safely decoding binary tool_call to JSON:", c), this.handleControlEvent(c)) : console.log("[VaniraAI] Decoded JSON from binary (inspect only):", c);
+            } catch {
+              console.log("[VaniraAI] Decoded String from binary:", s);
+            }
+          } catch {
+            console.log("[VaniraAI] Received binary data:", o.data.byteLength, "bytes (not decodable)");
+          }
+        else o.data instanceof Blob && o.data.text().then((s) => {
+          try {
+            this.handleControlEvent(JSON.parse(s));
+          } catch {
+            console.warn("[WebRTC] Failed to parse blob data:", s);
+          }
+        });
+      }, this.dataChannel.onerror = (o) => console.error("❌ [WebRTC] DataChannel error:", o), this.pc.ontrack = (o) => {
+        const s = o.track, c = o.streams[0];
+        console.log(`📥 [WebRTC] Received ${s.kind} track`), s.kind === "audio" ? (console.log("🔊 [WebRTC] Received audio track from server"), this.audioElement = new Audio(), this.audioElement.srcObject = c, this.audioElement.play().catch((p) => console.warn("Audio autoplay blocked:", p)), this.audioElement.onended = () => {
+          this.sendEvent("playedStream"), console.log("✅ [WebRTC] TTS playback complete");
+        }, this.onRemoteTrack(s, c)) : s.kind === "video" && (console.log("📹 [WebRTC] Video track received"), this.onRemoteTrack(s, c));
+      };
+      const n = () => {
+        var c, p, h, u, f, _, C, m, w, I, S;
+        console.log("🔄 [WebRTC] State:", (c = this.pc) == null ? void 0 : c.connectionState, "| ICE:", (p = this.pc) == null ? void 0 : p.iceConnectionState);
+        const o = ((h = this.pc) == null ? void 0 : h.connectionState) === "connected" || ((u = this.pc) == null ? void 0 : u.iceConnectionState) === "connected" || ((f = this.pc) == null ? void 0 : f.iceConnectionState) === "completed", s = ((_ = this.pc) == null ? void 0 : _.connectionState) === "failed" || ((C = this.pc) == null ? void 0 : C.iceConnectionState) === "failed" || ((m = this.pc) == null ? void 0 : m.connectionState) === "closed" || ((w = this.pc) == null ? void 0 : w.iceConnectionState) === "closed" || ((I = this.pc) == null ? void 0 : I.connectionState) === "disconnected" || ((S = this.pc) == null ? void 0 : S.iceConnectionState) === "disconnected";
+        o && !this.connected ? (this.connected = !0, this.onConnected()) : s && this.connected && (this.connected = !1, this.onDisconnected());
+      };
+      this.pc.onconnectionstatechange = n, this.pc.oniceconnectionstatechange = n;
+      const i = await this.pc.createOffer();
+      await this.pc.setLocalDescription(i), console.log("📝 [WebRTC] Created offer, waiting for ICE gathering..."), await this.waitForIceGathering(), console.log("🧊 [WebRTC] ICE gathering complete"), console.log("📤 [WebRTC] Sending offer via HTTP...");
+      const r = this.serverUrl.includes("?") ? this.serverUrl : `${this.serverUrl}/webrtc?agent=${this.agentId}_${this.callId}`, l = await fetch(r, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          offer: this.pc.localDescription,
+          agentId: this.agentId,
+          callId: this.callId
+        })
+      });
+      if (!l.ok) {
+        const o = await l.json();
+        throw new Error(o.error || `HTTP ${l.status}`);
+      }
+      const { answer: d } = await l.json();
+      console.log("📥 [WebRTC] Received answer from server"), await this.pc.setRemoteDescription(d), console.log("✅ [WebRTC] Connection established!");
+    } catch (t) {
+      throw console.error("❌ [WebRTC] Connection failed:", t), this.disconnect(), this.onError(t.message || t), t;
+    }
+  }
+  /**
+   * Wait for ICE gathering to complete
+   */
+  waitForIceGathering() {
+    return new Promise((e) => {
+      if (!this.pc) return e();
+      if (this.pc.iceGatheringState === "complete")
+        e();
+      else {
+        const t = () => {
+          var n, i;
+          ((n = this.pc) == null ? void 0 : n.iceGatheringState) === "complete" && ((i = this.pc) == null || i.removeEventListener("icegatheringstatechange", t), e());
+        };
+        this.pc.addEventListener("icegatheringstatechange", t), setTimeout(() => {
+          var n;
+          (n = this.pc) == null || n.removeEventListener("icegatheringstatechange", t), console.warn("⚠️ [WebRTC] ICE gathering timeout, proceeding anyway"), e();
+        }, 5e3);
+      }
+    });
+  }
+  /**
+   * Send control event via DataChannel
+   */
+  sendEvent(e, t = {}) {
+    var n;
+    if (((n = this.dataChannel) == null ? void 0 : n.readyState) === "open") {
+      const i = { event: e, ...t };
+      console.log(`📤 [WebRTC] Sending event: ${e}`, i), this.dataChannel.send(JSON.stringify(i));
+    } else
+      console.warn(`⚠️ [WebRTC] Cannot send event ${e} - DataChannel not open`);
+  }
+  /**
+   * Handle control events from server
+   */
+  handleControlEvent(e) {
+    var t;
+    switch (e.event) {
+      case "clearAudio":
+        console.log("🛑 [WebRTC] Interrupt: clearAudio received (leaving stream unpaused)");
+        break;
+      case "transcription":
+        console.log("📝 [WebRTC] Transcription:", e.text), this.onTranscription(e.text, e.isFinal);
+        break;
+      case "mark":
+        console.log("🏷️ [WebRTC] Mark:", e.name);
+        break;
+      case "client_tool_call": {
+        const n = e.tool_call || e.data || e, i = (n == null ? void 0 : n.tool_call_id) || (n == null ? void 0 : n.call_id) || e.tool_call_id || "";
+        i && ((t = this.dataChannel) == null ? void 0 : t.readyState) === "open" ? (this.dataChannel.send(JSON.stringify({
+          event: "client_tool_ack",
+          data: { tool_call_id: i }
+        })), console.log("✅ [VaniraAI] Sent client_tool_ack for:", i)) : i || console.warn("⚠️ [VaniraAI] client_tool_call received without tool_call_id — ack skipped");
+        const r = (n == null ? void 0 : n.arguments) || (n == null ? void 0 : n.args) || {}, l = (n == null ? void 0 : n.client_fields) || {}, d = (l == null ? void 0 : l.preset_id) || (r == null ? void 0 : r.preset_id);
+        if (d) {
+          console.log(`🎨 [VaniraAI] Preset detected: ${d}`), console.log("🎨 [VaniraAI] Tool args:", r), console.log("🎨 [VaniraAI] Client fields:", l), console.log(`🎨 [VaniraAI] Preset "${d}" — dispatching vanira:preset event`), window.dispatchEvent(new CustomEvent("vanira:preset", {
+            detail: { toolCall: n, client: this }
+          })), this.onClientToolCall(n);
+          break;
+        }
+        console.log("🛠️ [VaniraAI] Client Tool Call:", e), this.onClientToolCall(n);
+        break;
+      }
+      default:
+        console.log("ℹ️ [WebRTC] Unknown event:", e.event);
+    }
+  }
+  /**
+   * Disconnect and cleanup
+   */
+  disconnect() {
+    console.log("🔴 [WebRTC] Disconnecting..."), this.audioElement && (this.audioElement.pause(), this.audioElement.srcObject = null), this.dataChannel && (this.dataChannel.close(), this.dataChannel = null), this.pc && (this.pc.getSenders().forEach((e) => {
+      e.track && e.track.stop();
+    }), this.pc.close(), this.pc = null), this.localStream && (this.localStream.getTracks().forEach((e) => {
+      try {
+        e.stop();
+      } catch {
+      }
+    }), this.localStream = null), this.connected = !1, this.onDisconnected();
+  }
+  /**
+   * Generate unique call ID
+   */
+  generateCallId() {
+    return "web_" + Date.now() + "_" + Math.random().toString(36).substr(2, 8);
+  }
+  /**
+   * Send client-side tool execution result back to the AI server.
+   * Use this to unblock a 'blocking' execution mode tool.
+   */
+  sendToolResult(e, t) {
+    this.sendEvent("client_tool_result", {
+      call_id: e,
+      result: t
+    });
+  }
+  /**
+   * Send an acknowledgement that the client received a tool call and rendered it.
+   * This MUST be sent immediately upon receiving a 'client_tool_call' event.
+   * The SDK now sends this automatically, but this method is exposed for manual use.
+   * If the ack is not received within 2.3s, the AI will ask "Did something pop up?"
+   * Once acked, the server waits up to 10s for the client_tool_result.
+   */
+  sendToolAck(e) {
+    var t;
+    ((t = this.dataChannel) == null ? void 0 : t.readyState) === "open" ? (this.dataChannel.send(JSON.stringify({
+      event: "client_tool_ack",
+      data: { tool_call_id: e }
+    })), console.log("✅ [VaniraAI] Sent client_tool_ack for:", e)) : console.warn("⚠️ [VaniraAI] Cannot send tool_ack: DataChannel not open");
+  }
+  /**
+   * Silently update the AI's context with what the user is currently viewing.
+   * Does NOT interrupt the AI's current speech.
+   */
+  sendContextUpdate(e) {
+    this.sendEvent("client_context_update", { data: { context: e } });
+  }
+  /**
+   * Trigger a client-side action — forces the AI to react to a UI event.
+   */
+  sendActionTrigger(e, t = {}) {
+    this.sendEvent("client_action_trigger", {
+      data: {
+        action_name: e,
+        data: t
+      }
+    });
+  }
+  /**
+   * Trigger a client-side interrupt — cuts AI audio and forces it to react to a UI event.
+   */
+  triggerActionInterrupt() {
+    this.sendEvent("action_interrupt"), console.log("🛑 [VaniraAI] Triggered client-side action interrupt");
+  }
+  /**
+   * Uploads a file (photo, document, screenshot) to the media server
+   * and notifies the AI agent via the WebRTC control DataChannel.
+   * 
+   * @param file The file to upload (image, PDF, document)
+   * @param reason Routing key for backend processing (default: 'general')
+   * @param message Optional user text message about the file
+   */
+  async uploadMedia(e, t = "general", n = "") {
+    if (!this.serverUrl)
+      throw new Error("Upload failed: serverUrl is not set. Connect the WebRTCClient first.");
+    if (!this.callId)
+      throw new Error("Upload failed: callId is missing.");
+    let i = "";
+    try {
+      i = new URL(this.serverUrl).origin;
+    } catch {
+      i = this.serverUrl.replace(/\/webrtc.*$/, "").replace(/\/$/, "");
+    }
+    const r = `${i}/media/upload`, l = new FormData();
+    l.append("file", e), l.append("call_id", this.callId), l.append("reason", t), console.log(`[VaniraAI] Uploading media to ${r} (Call: ${this.callId}, Reason: ${t})...`);
+    const d = await fetch(r, {
+      method: "POST",
+      body: l
+    });
+    if (!d.ok) {
+      let h = `HTTP ${d.status}`;
+      try {
+        h = (await d.json()).error || h;
+      } catch {
+      }
+      throw new Error(`Upload failed: ${h}`);
+    }
+    const o = await d.json(), s = o.media_id, c = o.url, p = o.content_type || e.type;
+    if (!s || !c)
+      throw new Error("Upload failed: server response missing media_id or url");
+    if (console.log(`[VaniraAI] Media uploaded successfully. ID: ${s}, URL: ${c}`), this.dataChannel && this.dataChannel.readyState === "open") {
+      const h = {
+        event: "client_media_update",
+        data: {
+          media_id: s,
+          media_url: c,
+          content_type: p,
+          reason: t,
+          message: n
+        }
+      };
+      this.dataChannel.send(JSON.stringify(h)), console.log("[VaniraAI] Sent client_media_update notification via DataChannel:", h);
+    } else
+      console.warn("[VaniraAI] WebRTC DataChannel is not open. Media uploaded but AI notification skipped.");
+    return { media_id: s, url: c };
+  }
+  /**
+   * Fetch active STUN/TURN ICE servers from the Vanira API.
+   * @param apiKey  Your sk_live_* or pk_live_* key
+   * @param backendUrl  Override the default backend URL (default: https://api.vanira.io)
+   */
+  static async fetchIceServers(e, t = "https://api.vanira.io") {
+    try {
+      const n = await fetch(`${t}/discovery/ice-servers`, {
+        headers: { "X-API-Key": e }
+      });
+      if (!n.ok) throw new Error("Failed to fetch ICE servers");
+      return (await n.json()).ice_servers || [];
+    } catch (n) {
+      throw console.error("[WebRTC] Failed to fetch ICE servers:", n), n;
+    }
+  }
+}
+const y = {};
+class k {
+  constructor(e) {
+    a(this, "config");
+    a(this, "_status", "idle");
+    a(this, "client", null);
+    a(this, "listeners", /* @__PURE__ */ new Map());
+    if (!e.agentId) throw new Error("[VaniraAI] agentId is required");
+    this.config = e;
+  }
+  // ─── Getters ─────────────────────────────────────────────────────────────
+  /** Returns the active WebRTC worker/server URL */
+  get serverUrl() {
+    var e;
+    return (e = this.client) == null ? void 0 : e.serverUrl;
+  }
+  /** Returns the active call ID */
+  get callId() {
+    var e;
+    return (e = this.client) == null ? void 0 : e.callId;
+  }
+  /** Returns the active prospect ID associated with this session */
+  get prospectId() {
+    var e;
+    return (e = this.client) == null ? void 0 : e.prospectId;
+  }
+  // ─── Status ──────────────────────────────────────────────────────────────
+  /** Current connection status */
+  get status() {
+    return this._status;
+  }
+  /** Shorthand: true when status is 'connected' */
+  get isConnected() {
+    return this._status === "connected";
+  }
+  // ─── Event Emitter ───────────────────────────────────────────────────────
+  /**
+   * Register an event listener.
+   * @param event - Event name
+   * @param callback - Handler function
+   * @returns `this` for chaining
+   */
+  on(e, t) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), this;
+  }
+  /**
+   * Remove a previously registered event listener.
+   * @param event - Event name
+   * @param callback - The exact same function reference that was registered
+   */
+  off(e, t) {
+    var n;
+    return (n = this.listeners.get(e)) == null || n.delete(t), this;
+  }
+  emit(e, t) {
+    var n;
+    (n = this.listeners.get(e)) == null || n.forEach((i) => i(t));
+  }
+  // ─── Lifecycle ───────────────────────────────────────────────────────────
+  /**
+   * Connect to the Voice AI agent and start the call.
+   * Requests microphone permission, establishes WebRTC, and opens the data channel.
+   */
+  async start() {
+    if (this._status === "connecting" || this._status === "connected")
+      return console.warn("[VaniraAI] Already connecting or connected. Call stop() first."), {
+        callId: this.callId || "",
+        prospectId: this.prospectId || "",
+        serverUrl: this.serverUrl || ""
+      };
+    this._setStatus("connecting");
+    const e = this.config.serverUrl || (this.config.apiKey ? "" : this._inferServerUrl());
+    try {
+      return this.client = new b({
+        serverUrl: e,
+        agentId: this.config.agentId,
+        callId: this.config.callId,
+        prospectId: this.config.prospectId,
+        sessionBehavior: this.config.sessionBehavior,
+        token: this.config.token,
+        apiKey: this.config.apiKey,
+        backendUrl: this.config.backendUrl,
+        iceServers: this.config.iceServers,
+        runtime: this.config.runtime,
+        onSessionStarted: (t) => {
+          this.emit("session_started", t);
+        },
+        onConnected: () => {
+          this._setStatus("connected"), this.emit("connected");
+        },
+        onDisconnected: () => {
+          this._setStatus("disconnected"), this.emit("disconnected");
+        },
+        onError: (t) => {
+          this._setStatus("error"), this.emit("error", typeof t == "string" ? t : (t == null ? void 0 : t.message) || "Connection failed");
+        },
+        onTranscription: (t, n) => {
+          this.emit("transcription", { text: t, isFinal: n });
+        },
+        // @ts-ignore - onClientToolCall is on the dashboard's WebRTCClient; proxy it here
+        onClientToolCall: (t) => {
+          const n = (t == null ? void 0 : t.data) || t, i = {
+            name: n.name || n.tool_name || "",
+            arguments: n.arguments || n.args || {},
+            tool_call_id: n.tool_call_id || n.call_id || "",
+            execution_mode: n.execution_mode || "fire_and_forget",
+            client_fields: n.client_fields || {}
+          };
+          this.emit("tool_call", i);
+        },
+        // @ts-ignore - onRemoteTrack is on the dashboard's WebRTCClient; proxy it here
+        onRemoteTrack: (t, n) => {
+          this.emit("track", { track: t, stream: n });
+        }
+      }), await this.client.connect(), {
+        callId: this.callId || "",
+        prospectId: this.prospectId || "",
+        serverUrl: this.serverUrl || ""
+      };
+    } catch (t) {
+      throw this._setStatus("error"), this.emit("error", (t == null ? void 0 : t.message) || "Failed to start call"), t;
+    }
+  }
+  /**
+   * Disconnect the call and release all resources (microphone, WebRTC connection).
+   */
+  stop() {
+    this.client && (this.client.disconnect(), this.client = null), this._setStatus("disconnected");
+  }
+  // ─── Client → Server Actions ─────────────────────────────────────────────
+  /**
+   * Send the result of a **blocking** client-side tool back to the AI.
+   * The AI is paused and will resume once it receives this.
+   *
+   * @param toolCallId - The `tool_call_id` from the `tool_call` event
+   * @param result - Arbitrary JSON payload the AI needs to continue
+   *
+   * @example
+   * client.sendToolResult(tool_call_id, { selected_store: 'Store #5' });
+   */
+  sendToolResult(e, t) {
+    this._assertConnected("sendToolResult"), this.client.sendToolResult(e, t);
+  }
+  /**
+   * Send an error result for a **blocking** client-side tool.
+   * Use when the user cancelled or the UI crashed.
+   *
+   * @param toolCallId - The `tool_call_id` from the `tool_call` event
+   * @param errorMessage - Human-readable error description
+   */
+  sendToolError(e, t) {
+    this._assertConnected("sendToolError"), this.client.sendEvent("client_tool_result", {
+      call_id: e,
+      result: { status: "error", error: t }
+    });
+  }
+  /**
+   * Silently update the AI's context with what the user is currently doing on screen.
+   * Does NOT interrupt the AI's current speech.
+   *
+   * @example
+   * client.updateContext({ active_page: 'Checkout', item: 'Nike Shoes', price: 149.99 });
+   */
+  updateContext(e) {
+    this._assertConnected("updateContext"), this.client.sendContextUpdate(e);
+  }
+  /**
+   * Force the AI to stop speaking and immediately react to a UI event.
+   * Use when the user performs a significant action (e.g., clicks a button, opens a page).
+   *
+   * Do NOT call this after `uploadMedia()` — `uploadMedia()` already sends
+   * `client_media_update` which is the only notification the backend needs.
+   * Calling `triggerInterrupt` after an upload causes double-TTS.
+   *
+   * @param actionName - A descriptive name for the action (e.g., 'user_clicked_cart')
+   * @param data - Optional context about the action
+   *
+   * @example
+   * client.triggerInterrupt('user_opened_checkout', { cart_value: 299 });
+   */
+  triggerInterrupt(e, t = {}) {
+    this._assertConnected("triggerInterrupt"), this.client.triggerActionInterrupt(), this.client.sendActionTrigger(e, t);
+  }
+  /**
+   * Cut the AI's current audio mid-sentence WITHOUT sending a client_action_trigger.
+   * Use this when you want to interrupt the agent but the next notification will be
+   * sent by the SDK itself (e.g. right before `uploadMedia()`).
+   */
+  interruptAudioOnly() {
+    this._assertConnected("interruptAudioOnly"), this.client.triggerActionInterrupt();
+  }
+  /**
+   * Upload a file (photo, document, screenshot) to the AI agent during a live call.
+   * Handles the HTTP upload and DataChannel notification automatically.
+   *
+   * ⚠️  This method is SELF-CONTAINED:
+   *   1. POSTs the file to /media/upload
+   *   2. Sends `client_media_update` via the DataChannel
+   *
+   * The backend LLM receives `client_media_update` and calls `process_media` — NO
+   * additional `triggerInterrupt()` or `sendActionTrigger()` is needed.
+   * Calling those after `uploadMedia()` will cause a SECOND LLM response (double TTS).
+   *
+   * @param file            - File or Blob to upload (JPEG, PNG, GIF, WebP, PDF — max 50 MB)
+   * @param reason          - Routing key: 'general' | 'kyc_photo' | 'damage_photo' | 'selfie' | 'document' | 'screenshot'
+   * @param message         - Optional text the user wants to say about the file
+   * @param interruptFirst  - Pass `true` to cut the AI's current audio before uploading
+   *                          (sends `action_interrupt` only — NOT `client_action_trigger`)
+   * @returns               `{ media_id, url }` on success
+   *
+   * @example
+   * // Correct — one event, full context, LLM gets everything:
+   * const result = await client.uploadMedia(file, 'person_verification', 'Here is my ID', true);
+   *
+   * // ❌ Wrong — causes double TTS:
+   * const result = await client.uploadMedia(file, 'person_verification');
+   * client.triggerInterrupt('media_uploaded', { url: result.url }); // don't do this
+   */
+  async uploadMedia(e, t = "general", n = "", i = !1) {
+    this._assertConnected("uploadMedia"), i && this.client.triggerActionInterrupt();
+    const r = 50 * 1024 * 1024;
+    if (e.size > r)
+      throw new Error(`Upload failed: file is too large (${(e.size / 1024 / 1024).toFixed(1)} MB). Maximum is 50 MB.`);
+    const l = [
+      "image/jpeg",
+      "image/png",
+      "image/gif",
+      "image/webp",
+      "image/bmp",
+      "application/pdf"
+    ], d = e.type;
+    if (d && !l.includes(d))
+      throw new Error(`Upload failed: unsupported file type '${d}'. Supported: JPEG, PNG, GIF, WebP, BMP, PDF.`);
+    return this.client.uploadMedia(e, t, n);
+  }
+  // ─── Private helpers ─────────────────────────────────────────────────────
+  _setStatus(e) {
+    this._status = e;
+  }
+  _inferServerUrl() {
+    return (typeof import.meta < "u" && y || {}).VITE_WEBRTC_SERVER_URL || "https://in-godspeed.travelr.club";
+  }
+  _assertConnected(e) {
+    if (!this.client || !this.isConnected)
+      throw new Error(`[VaniraAI] Cannot call ${e}() when not connected. Call start() first.`);
+  }
+}
+export {
+  k as V,
+  b as W
+};