@vanira/sdk 0.0.82

package/dist/platforms/browser.js

@@ -0,0 +1,1540 @@
+var ne = Object.defineProperty;
+var ae = (s, e, t) => e in s ? ne(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var l = (s, e, t) => ae(s, typeof e != "symbol" ? e + "" : e, t);
+class ie {
+  constructor(e) {
+    l(this, "el");
+    this.el = new Audio(), this.el.srcObject = e, this.el.play().catch(
+      (t) => {
+      }
+    );
+  }
+  pause() {
+  }
+  cleanup() {
+    this.el.pause(), this.el.srcObject = null;
+  }
+  onEnded(e) {
+    this.el.onended = e;
+  }
+}
+class se {
+  createRemotePlayer(e) {
+    return new ie(e);
+  }
+}
+class re {
+  async getUserAudio(e) {
+    return navigator.mediaDevices.getUserMedia({ audio: e });
+  }
+  stopStream(e) {
+    e.getTracks().forEach((t) => t.stop());
+  }
+}
+class oe {
+  create(e) {
+    return new RTCPeerConnection({
+      iceServers: e.iceServers,
+      iceTransportPolicy: e.iceTransportPolicy ?? "all"
+    });
+  }
+}
+const ce = /* @__PURE__ */ new Set([
+  "client_tool_call",
+  "clearAudio",
+  "client_tool_cancel"
+]);
+function X(s) {
+  if (!s || typeof s != "object") return !1;
+  const e = s.event;
+  return typeof e == "string" && ce.has(e);
+}
+class le {
+  bind(e, t) {
+    return e.onopen = () => t.onOpen(), e.onerror = (n) => t.onError(n), e.onmessage = (n) => {
+      if (typeof n.data == "string") {
+        t.onMessage({ text: n.data });
+        return;
+      }
+      if (n.data instanceof ArrayBuffer) {
+        try {
+          const a = new TextDecoder().decode(n.data), i = JSON.parse(a);
+          X(i) && t.onMessage({ text: a });
+        } catch {
+        }
+        return;
+      }
+      n.data instanceof Blob && n.data.text().then((a) => {
+        t.onMessage({ text: a });
+      }).catch((a) => {
+      });
+    }, {
+      send(n) {
+        e.readyState === "open" && e.send(n);
+      },
+      isOpen() {
+        return e.readyState === "open";
+      },
+      close() {
+        e.close();
+      }
+    };
+  }
+}
+const V = "https://api.vanira.io", p = {
+  Form: "vanira_form",
+  Calendar: "vanira_calendar",
+  Navigate: "vanira_navigate",
+  Upload: "vanira_upload",
+  Camera: "vanira_camera",
+  HighlightElement: "vanira_highlight_element",
+  ClickElement: "vanira_click_element",
+  SelectOption: "vanira_select_option",
+  SetDate: "vanira_set_date",
+  TypeText: "vanira_type_text",
+  EraseText: "vanira_erase_text",
+  Draw: "vanira_draw",
+  EraseDraw: "vanira_erase_draw",
+  LiveVision: "vanira_live_vision",
+  CloseLiveCamera: "vanira_close_live_camera",
+  LiveScreen: "vanira_live_screen",
+  CloseLiveScreen: "vanira_close_live_screen",
+  ClipRegion: "vanira_clip_region",
+  TabScreenshot: "vanira_tab_screenshot",
+  ScreenInk: "vanira_screen_ink",
+  ScreenCursor: "vanira_screen_cursor",
+  ScreenClick: "vanira_screen_click",
+  ClearScreenOverlay: "vanira_clear_screen_overlay",
+  PageScan: "vanira_page_scan",
+  PointAt: "vanira_point_at",
+  OutlineTargets: "vanira_outline_targets",
+  ClearGuide: "vanira_clear_guide"
+}, de = Object.values(p), he = new Set(de);
+function J(s) {
+  return !!s && he.has(s);
+}
+const ue = /* @__PURE__ */ new Set([
+  p.ScreenInk,
+  p.ScreenCursor,
+  p.ScreenClick,
+  p.ClearScreenOverlay,
+  p.PointAt,
+  p.OutlineTargets,
+  p.ClearGuide
+]);
+[
+  ...ue,
+  p.PageScan,
+  p.TabScreenshot
+];
+function Z(s) {
+  if (typeof s == "string")
+    try {
+      return JSON.parse(s);
+    } catch {
+      return {};
+    }
+  return s && typeof s == "object" ? s : {};
+}
+const W = {
+  type_on_whiteboard: p.TypeText,
+  write_on_whiteboard: p.TypeText,
+  write_on_white_board: p.TypeText,
+  dom_typing_simulation: p.TypeText,
+  erase_text: p.EraseText,
+  dom_erase: p.EraseText,
+  draw_on_board: p.Draw,
+  erase_drawing_board: p.EraseDraw,
+  open_live_camera: p.LiveVision,
+  live_vision: p.LiveVision,
+  close_live_camera: p.CloseLiveCamera,
+  stop_live_camera: p.CloseLiveCamera,
+  open_live_screen: p.LiveScreen,
+  close_live_screen: p.CloseLiveScreen,
+  screen_ink: p.ScreenInk,
+  screen_cursor: p.ScreenCursor,
+  screen_click: p.ScreenClick,
+  clear_screen_overlay: p.ClearScreenOverlay,
+  tab_screenshot: p.TabScreenshot,
+  capture_tab: p.TabScreenshot,
+  capture_tab_screenshot: p.TabScreenshot,
+  screenshot_tab: p.TabScreenshot,
+  page_scan: p.PageScan,
+  scan_page: p.PageScan,
+  point_at: p.PointAt,
+  outline_targets: p.OutlineTargets,
+  outline_elements: p.OutlineTargets,
+  clear_guide: p.ClearGuide
+};
+function G(s, e) {
+  const t = s.text_to_type ?? (e == null ? void 0 : e.text_to_type) ?? s.text ?? (e == null ? void 0 : e.text) ?? s.value ?? (e == null ? void 0 : e.value);
+  return typeof t == "string" && t.trim().length > 0;
+}
+function pe(s, e) {
+  const t = s.fields ?? (e == null ? void 0 : e.fields);
+  return Array.isArray(t) ? t.length > 0 : typeof t == "string" ? t.split(",").map((n) => n.trim()).filter(Boolean).length > 0 : !1;
+}
+function _e(s, e) {
+  const t = s == null ? void 0 : s.preset_id;
+  if (typeof t == "string" && J(t))
+    return t;
+  const a = Z(e).preset_id;
+  if (typeof a == "string" && J(a))
+    return a;
+}
+function fe(s, e, t) {
+  const n = Z(e);
+  let a = _e(s, n);
+  if (a === p.Form && G(n, s) && !pe(n, s))
+    return p.TypeText;
+  if (a) return a;
+  const i = String(t ?? "").trim().toLowerCase();
+  if (i && W[i])
+    return W[i];
+  if (G(n, s))
+    return p.TypeText;
+}
+const U = "vanira_latest_call_id", B = "vanira_prospect_id";
+function x(s) {
+  return `vanira_latest_call_id_${s}`;
+}
+function M(s) {
+  return `vanira_prospect_id_${s}`;
+}
+function Q(s) {
+  return `vanira_call_meta_${s}`;
+}
+function C(s, e) {
+  if (!s) return null;
+  try {
+    return s.getItem(e);
+  } catch {
+    return null;
+  }
+}
+function z(s) {
+  if (typeof window > "u" || !s) return null;
+  const e = [], t = C(window.localStorage, Q(s));
+  if (t)
+    try {
+      const c = JSON.parse(t);
+      c != null && c.callId && e.push({
+        callId: c.callId,
+        prospectId: c.prospectId,
+        updatedAt: c.updatedAt || 0
+      });
+    } catch {
+    }
+  const n = (c, r, h) => {
+    c && e.push({
+      callId: c,
+      prospectId: r || void 0,
+      updatedAt: h
+    });
+  }, a = C(window.localStorage, M(s)), i = C(window.sessionStorage, M(s)), o = C(window.localStorage, B);
+  return n(
+    C(window.localStorage, x(s)),
+    a || o,
+    2
+  ), n(
+    C(window.sessionStorage, x(s)),
+    i || o,
+    1
+  ), n(C(window.localStorage, U), o, 0), n(C(window.sessionStorage, U), o, 0), e.length ? (e.sort((c, r) => r.updatedAt - c.updatedAt), e[0]) : null;
+}
+function me(s, e, t) {
+  var a, i, o, c, r, h, u, d, _;
+  if (typeof window > "u" || !s || !e) return;
+  const n = {
+    callId: e,
+    prospectId: t,
+    updatedAt: Date.now()
+  };
+  try {
+    (a = window.localStorage) == null || a.setItem(Q(s), JSON.stringify(n)), (i = window.localStorage) == null || i.setItem(x(s), e), (o = window.sessionStorage) == null || o.setItem(x(s), e), t && ((c = window.localStorage) == null || c.setItem(M(s), t), (r = window.sessionStorage) == null || r.setItem(M(s), t)), (h = window.localStorage) == null || h.setItem(U, e), (u = window.sessionStorage) == null || u.setItem(U, e), t && ((d = window.localStorage) == null || d.setItem(B, t), (_ = window.sessionStorage) == null || _.setItem(B, t));
+  } catch {
+  }
+}
+const $ = 16 * 1024, we = 256 * 1024;
+function D(s, e) {
+  return (s == null ? void 0 : s.readyState) === "open" && (e == null ? void 0 : e.readyState) === "open";
+}
+function Se(s, e) {
+  return {
+    control: (s == null ? void 0 : s.readyState) ?? "missing",
+    mediaBytes: (e == null ? void 0 : e.readyState) ?? "missing"
+  };
+}
+async function ye(s, e, t = 8e3) {
+  if (D(s, e))
+    return !0;
+  const n = Date.now() + t;
+  for (; Date.now() < n; ) {
+    if (D(s, e))
+      return !0;
+    await new Promise((a) => setTimeout(a, 50));
+  }
+  return D(s, e);
+}
+async function Y(s) {
+  for (; s.bufferedAmount > we; )
+    await new Promise((e) => setTimeout(e, 10));
+}
+async function ve(s) {
+  const {
+    bytes: e,
+    filename: t,
+    contentType: n,
+    reason: a,
+    message: i,
+    callId: o,
+    mediaBytesChannel: c,
+    sendControlEvent: r,
+    uploadId: h = crypto.randomUUID(),
+    uploadKind: u = "media"
+  } = s, d = e.byteLength, _ = d === 0 ? 0 : Math.ceil(d / $);
+  r("client_media_upload_start", {
+    data: {
+      upload_id: h,
+      call_id: o,
+      reason: a,
+      message: i,
+      filename: t,
+      content_type: n,
+      size: d,
+      chunk_count: _,
+      upload_kind: u
+    }
+  });
+  const f = new Uint8Array(e);
+  for (let m = 0; m < d; m += $) {
+    await Y(c);
+    const S = Math.min(m + $, d);
+    c.send(f.subarray(m, S));
+  }
+  return await Y(c), r("client_media_upload_complete", {
+    data: {
+      upload_id: h,
+      call_id: o,
+      reason: a,
+      message: i,
+      chunk_count: _,
+      upload_kind: u
+    }
+  }), { media_id: h, url: "", content_type: n };
+}
+async function ge(s) {
+  return typeof s.arrayBuffer == "function" ? s.arrayBuffer() : new Response(s).arrayBuffer();
+}
+function Ce(s) {
+  return null;
+}
+function O() {
+  return typeof window > "u" ? "/" : `${window.location.pathname}${window.location.search}${window.location.hash}` || "/";
+}
+class Ie {
+  constructor(e) {
+    l(this, "active", !1);
+    l(this, "initialSent", !1);
+    l(this, "lastRoute", "");
+    l(this, "sendContext");
+    l(this, "isReady");
+    l(this, "cleanupFns", []);
+    l(this, "initialRetryTimer", null);
+    l(this, "routePollTimer", null);
+    l(this, "originalPushState", null);
+    l(this, "originalReplaceState", null);
+    this.sendContext = e.sendContext, this.isReady = e.isReady ?? (() => !0);
+  }
+  start() {
+    typeof window > "u" || this.active || (this.active = !0, this.initialSent = !1, this.lastRoute = O(), this.attachListeners(), this.scheduleInitialContextSend());
+  }
+  stop() {
+    if (!(!this.active && this.cleanupFns.length === 0)) {
+      this.active = !1, this.initialSent = !1, this.initialRetryTimer !== null && (clearTimeout(this.initialRetryTimer), this.initialRetryTimer = null), this.routePollTimer !== null && (clearInterval(this.routePollTimer), this.routePollTimer = null);
+      for (const e of this.cleanupFns)
+        try {
+          e();
+        } catch {
+        }
+      this.cleanupFns.length = 0, this.originalPushState && (history.pushState = this.originalPushState, this.originalPushState = null), this.originalReplaceState && (history.replaceState = this.originalReplaceState, this.originalReplaceState = null);
+    }
+  }
+  /** Call when the WebRTC data channel opens (initial context may have been deferred). */
+  onChannelReady() {
+    this.scheduleInitialContextSend();
+  }
+  scheduleInitialContextSend(e = 0) {
+    if (!(!this.active || this.initialSent)) {
+      if (this.isReady()) {
+        this.sendRouteContext("call_started"), this.initialSent = !0;
+        return;
+      }
+      e >= 30 || (this.initialRetryTimer = window.setTimeout(
+        () => this.scheduleInitialContextSend(e + 1),
+        100
+      ));
+    }
+  }
+  attachListeners() {
+    const e = (i, o = 0) => {
+      const c = () => {
+        const r = O();
+        r !== this.lastRoute && this.handleRouteChange(r, i);
+      };
+      o > 0 ? window.setTimeout(c, o) : queueMicrotask(c);
+    }, t = () => e("popstate"), n = () => e("hashchange"), a = (i) => {
+      const o = i.detail;
+      if ((o == null ? void 0 : o.initiated_by) === "agent") {
+        e("vanira_navigate_agent", 120);
+        return;
+      }
+      e("vanira_navigate", 120);
+    };
+    window.addEventListener("popstate", t), window.addEventListener("hashchange", n), window.addEventListener("vanira:navigate", a), this.cleanupFns.push(
+      () => window.removeEventListener("popstate", t),
+      () => window.removeEventListener("hashchange", n),
+      () => window.removeEventListener("vanira:navigate", a)
+    ), this.originalPushState = history.pushState.bind(history), this.originalReplaceState = history.replaceState.bind(history), history.pushState = (...i) => {
+      this.originalPushState(...i), e("pushState");
+    }, history.replaceState = (...i) => {
+      this.originalReplaceState(...i), e("replaceState");
+    }, this.routePollTimer = window.setInterval(() => {
+      if (!this.active) return;
+      const i = O();
+      i !== this.lastRoute && this.handleRouteChange(i, "location_poll");
+    }, 1e3);
+  }
+  handleRouteChange(e, t) {
+    if (!this.active) return;
+    const n = this.lastRoute;
+    if (n === e) return;
+    if (this.lastRoute = e, !this.initialSent) {
+      this.scheduleInitialContextSend();
+      return;
+    }
+    !this.isReady() || Ce() || this.sendRouteContext("route_changed", n, t, "user");
+  }
+  sendRouteContext(e, t, n, a = "user") {
+    const i = O();
+    this.lastRoute = i;
+    const o = {
+      ui_state: "page_navigation",
+      navigation_led_by: a,
+      current_route: i,
+      current_page: i,
+      user_action: e === "call_started" ? "call_started_on_page" : "user_navigated"
+    };
+    e === "call_started" ? o.message = `User started the call while viewing ${i}.` : (o.previous_route = t ?? "", o.message = `User navigated from ${t || "(unknown)"} to ${i}.`, n && (o.navigation_source = n));
+    try {
+      this.sendContext(o);
+    } catch {
+    }
+  }
+}
+const y = class y {
+  constructor(e) {
+    l(this, "serverUrl");
+    l(this, "agentId");
+    l(this, "callId");
+    l(this, "prospectId");
+    l(this, "apiKey");
+    l(this, "backendUrl");
+    l(this, "token");
+    l(this, "onConnected");
+    l(this, "onDisconnected");
+    l(this, "onError");
+    l(this, "onTranscription");
+    l(this, "onLocalStream");
+    // @ts-ignore
+    l(this, "onRemoteTrack");
+    l(this, "onClientToolCall");
+    l(this, "onSessionStarted");
+    l(this, "sessionStartedEmitted", !1);
+    l(this, "pc", null);
+    l(this, "dataChannel", null);
+    l(this, "mediaBytesChannel", null);
+    l(this, "audioElement", null);
+    l(this, "localStream", null);
+    l(this, "micMuted", !1);
+    l(this, "connected", !1);
+    l(this, "icePollInterval", null);
+    l(this, "appliedRemoteCandidates", /* @__PURE__ */ new Set());
+    l(this, "iceServers");
+    l(this, "callSessionLoaded", !1);
+    l(this, "connectGeneration", 0);
+    l(this, "runtime");
+    l(this, "sessionBehavior");
+    l(this, "routeTracker", null);
+    l(this, "_status", "idle");
+    l(this, "listeners", /* @__PURE__ */ new Map());
+    /** Live vision config — auto-starts camera on connect when scope is full_call. */
+    l(this, "liveVision");
+    l(this, "liveVisionAutoStarted", !1);
+    if (!e.agentId) throw new Error("agentId is required");
+    const t = !!(e.apiKey || e.token), n = !!(e.serverUrl && e.callId), a = y.normalizeIceServers(
+      e.iceServers
+    );
+    if (!t && !n)
+      throw new Error(
+        "apiKey or token is required — or pass serverUrl and callId from a prior POST /calls/create"
+      );
+    this.agentId = e.agentId, this.sessionBehavior = e.sessionBehavior, this.serverUrl = (e.serverUrl || "").replace(/\/$/, ""), this.apiKey = e.apiKey, this.token = e.token, this.backendUrl = (e.backendUrl || V).replace(/\/$/, ""), a.length && (this.iceServers = a), n && (this.callSessionLoaded = !0);
+    const i = typeof window < "u";
+    this.prospectId = e.prospectId;
+    const o = e.sessionBehavior === "continue";
+    if (o && i && !e.callId) {
+      const r = z(this.agentId);
+      r && (e.callId || (this.callId = r.callId), !this.prospectId && r.prospectId && (this.prospectId = r.prospectId));
+    }
+    if (!this.prospectId && i)
+      try {
+        const r = z(this.agentId);
+        this.prospectId = (r == null ? void 0 : r.prospectId) || window.sessionStorage && window.sessionStorage.getItem("vanira_prospect_id") || window.localStorage && window.localStorage.getItem("vanira_prospect_id") || void 0;
+      } catch {
+      }
+    e.callId ? this.callId = e.callId : o || (this.callId = void 0);
+    const c = e.onSessionStarted;
+    this.onSessionStarted = (r) => {
+      c == null || c(r), this.emit("session_started", r);
+    }, this.liveVision = e.liveVision, this.onConnected = () => {
+      var r;
+      this._status = "connected", (r = e.onConnected) == null || r.call(e), this.emit("connected"), this.maybeAutoStartLiveCamera();
+    }, this.onDisconnected = () => {
+      var r;
+      this._status = "disconnected", (r = e.onDisconnected) == null || r.call(e), this.emit("disconnected");
+    }, this.onError = (r) => {
+      var u;
+      this._status = "error";
+      const h = typeof r == "string" ? r : (r == null ? void 0 : r.message) || "Connection error";
+      (u = e.onError) == null || u.call(e, r), this.emit("error", h);
+    }, this.onTranscription = (r, h) => {
+      var u;
+      (u = e.onTranscription) == null || u.call(e, r, h), this.emit("transcription", { text: r, isFinal: h });
+    }, this.onLocalStream = e.onLocalStream || (() => {
+    }), this.onRemoteTrack = (r, h) => {
+      var u;
+      (u = e.onRemoteTrack) == null || u.call(e, r, h), this.emit("track", { track: r, stream: h });
+    }, this.onClientToolCall = (r) => {
+      var d;
+      (d = e.onClientToolCall) == null || d.call(e, r);
+      const h = (r == null ? void 0 : r.data) || r, u = {
+        name: String(h.name || h.tool_name || ""),
+        arguments: h.arguments || h.args || {},
+        tool_call_id: String(h.tool_call_id || h.call_id || ""),
+        execution_mode: h.execution_mode === "blocking" ? "blocking" : "fire_and_forget",
+        client_fields: h.client_fields || {}
+      };
+      u.name && u.tool_call_id && this.emit("tool_call", u);
+    }, this.runtime = e.runtime, typeof window < "u" && e.trackRouteContext !== !1 && (this.routeTracker = new Ie({
+      sendContext: (r) => this.sendContextUpdate(r),
+      isReady: () => {
+        var r;
+        return ((r = this.dataChannel) == null ? void 0 : r.readyState) === "open";
+      }
+    }));
+  }
+  /**
+   * Create a call via POST /calls/create, then connect over WebRTC.
+   * Alias for connect() when using apiKey.
+   */
+  async createCall() {
+    return this.connect();
+  }
+  /**
+   * Connect to the agent (Talk to Agent — two phases).
+   *
+   * Phase 1: POST /calls/create → call_id, worker_url, ice_servers (fires onSessionStarted).
+   * Phase 2: getUserMedia → WebRTC offer to worker_url → ICE trickle → live audio (fires onConnected).
+   *
+   * Must be called from a user gesture (button click) for microphone access.
+   * onSessionStarted means provisioned only — wait for onConnected before the call is live.
+   */
+  async connect() {
+    var t;
+    this._status = "connecting";
+    const e = ++this.connectGeneration;
+    if (await this.loadCallSession(), !this.isConnectCancelled(e)) {
+      if (!this.serverUrl)
+        throw new Error("[VaniraClient] worker_url missing from /calls/create");
+      if (!this.callId)
+        throw new Error("[VaniraClient] call_id missing — must come from POST /calls/create");
+      if (this.onSessionStarted && this.prospectId && this.callId && !this.sessionStartedEmitted)
+        try {
+          this.onSessionStarted({ prospectId: this.prospectId, callId: this.callId, serverUrl: this.serverUrl }), this.sessionStartedEmitted = !0;
+        } catch {
+        }
+      try {
+        this.appliedRemoteCandidates.clear(), this.stopRemoteIcePolling();
+        const n = this.getIceServers();
+        this.pc = new RTCPeerConnection({
+          iceServers: n,
+          iceTransportPolicy: "all"
+        });
+        let a;
+        try {
+          a = await navigator.mediaDevices.getUserMedia({
+            audio: {
+              echoCancellation: !0,
+              noiseSuppression: !0,
+              autoGainControl: !0,
+              sampleRate: { ideal: 16e3 },
+              channelCount: 1
+            }
+          });
+        } catch (d) {
+          if (d.name === "NotAllowedError" || d.name === "PermissionDeniedError" || (t = d.message) != null && t.includes("Permission denied")) {
+            const _ = navigator.userAgent, f = /iPad|iPhone|iPod/.test(_) || navigator.platform === "MacIntel" && navigator.maxTouchPoints > 1;
+            let m = "Microphone access denied. Please allow microphone access in your browser settings.";
+            f && (_.includes("CriOS") ? m = "Microphone access blocked. Please enable it in iOS Settings > Chrome > Microphone, then reload the page." : _.includes("FxiOS") ? m = "Microphone access blocked. Please enable it in iOS Settings > Firefox > Microphone, then reload the page." : m = "Microphone access blocked. Please enable it in iOS Settings > Safari > Microphone (or tap 'aA' > Website Settings > Allow Microphone).");
+            const S = new Error(m);
+            throw S.name = d.name, S;
+          }
+          throw d;
+        }
+        if (this.isConnectCancelled(e)) {
+          a.getTracks().forEach((d) => d.stop());
+          return;
+        }
+        if (this.localStream = a, !this.pc || this.isConnectCancelled(e)) {
+          a.getTracks().forEach((d) => d.stop());
+          return;
+        }
+        if (this.onLocalStream(a), a.getTracks().forEach((d) => {
+          var _;
+          (_ = this.pc) == null || _.addTrack(d, a);
+        }), !this.pc)
+          throw new Error("RTCPeerConnection was closed unexpectedly");
+        this.dataChannel = this.pc.createDataChannel("control"), this.dataChannel.onopen = () => {
+          var d;
+          (d = this.routeTracker) == null || d.onChannelReady();
+        }, this.dataChannel.onmessage = (d) => {
+          if (typeof d.data == "string")
+            try {
+              this.handleControlEvent(JSON.parse(d.data));
+            } catch {
+            }
+          else if (d.data instanceof ArrayBuffer)
+            try {
+              const _ = new TextDecoder().decode(d.data);
+              try {
+                const f = JSON.parse(_);
+                X(f) && this.handleControlEvent(f);
+              } catch {
+              }
+            } catch {
+            }
+          else d.data instanceof Blob && d.data.text().then((_) => {
+            try {
+              this.handleControlEvent(JSON.parse(_));
+            } catch {
+            }
+          });
+        }, this.dataChannel.onerror = (d) => {
+        }, this.mediaBytesChannel = this.pc.createDataChannel("media-bytes", { ordered: !0 }), this.mediaBytesChannel.binaryType = "arraybuffer", this.mediaBytesChannel.onopen = () => {
+        }, this.mediaBytesChannel.onerror = (d) => {
+        }, this.pc.ontrack = (d) => {
+          const _ = d.track, f = d.streams[0];
+          _.kind === "audio" ? (this.audioElement = new Audio(), this.audioElement.srcObject = f, this.audioElement.play().catch((m) => {
+          }), this.audioElement.onended = () => {
+            this.sendEvent("playedStream"), typeof window < "u" && window.dispatchEvent(new CustomEvent("vanira:agent-playback-ended"));
+          }, this.onRemoteTrack(_, f)) : _.kind === "video" && this.onRemoteTrack(_, f);
+        };
+        const i = () => {
+          var f, m, S, T, E, R, k, I, v, g, P;
+          const d = ((f = this.pc) == null ? void 0 : f.connectionState) === "connected" || ((m = this.pc) == null ? void 0 : m.iceConnectionState) === "connected" || ((S = this.pc) == null ? void 0 : S.iceConnectionState) === "completed", _ = ((T = this.pc) == null ? void 0 : T.connectionState) === "failed" || ((E = this.pc) == null ? void 0 : E.iceConnectionState) === "failed" || ((R = this.pc) == null ? void 0 : R.connectionState) === "closed" || ((k = this.pc) == null ? void 0 : k.iceConnectionState) === "closed" || ((I = this.pc) == null ? void 0 : I.connectionState) === "disconnected" || ((v = this.pc) == null ? void 0 : v.iceConnectionState) === "disconnected";
+          ((g = this.pc) == null ? void 0 : g.connectionState) === "connected" && this.stopRemoteIcePolling(), d && !this.connected ? (this.connected = !0, (P = this.routeTracker) == null || P.start(), this.onConnected()) : _ && this.connected && (this.connected = !1, this.liveVisionAutoStarted = !1, this.onDisconnected());
+        };
+        this.pc.onconnectionstatechange = i, this.pc.oniceconnectionstatechange = i;
+        const o = this.getIceTrickleUrl();
+        this.pc.onicecandidate = (d) => {
+          d.candidate && fetch(o, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ candidate: d.candidate.toJSON() })
+          }).catch((_) => {
+          });
+        };
+        const c = await this.pc.createOffer();
+        if (this.isConnectCancelled(e) || (await this.pc.setLocalDescription(c), this.isConnectCancelled(e))) return;
+        const r = this.serverUrl.includes("?") ? this.serverUrl : `${this.serverUrl}/webrtc?agent=${this.agentId}_${this.callId}`, h = await fetch(r, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            offer: this.pc.localDescription,
+            agentId: this.agentId,
+            callId: this.callId
+          })
+        });
+        if (this.isConnectCancelled(e)) return;
+        if (!h.ok) {
+          const d = await h.json();
+          throw new Error(d.error || `HTTP ${h.status}`);
+        }
+        const { answer: u } = await h.json();
+        if (this.isConnectCancelled(e) || !this.pc || (await this.pc.setRemoteDescription(u), this.isConnectCancelled(e))) return;
+        this.startRemoteIcePolling(o);
+      } catch (n) {
+        if (this.isConnectCancelled(e)) return;
+        throw this.disconnect(), this.onError(n.message || n), n;
+      }
+    }
+  }
+  createCallCacheKey(e, t) {
+    const n = this.apiKey ? `key:${this.apiKey.slice(0, 16)}` : `token:${(this.token || "").slice(-16)}`;
+    return [
+      this.backendUrl,
+      this.agentId,
+      e,
+      t || "",
+      this.prospectId || "",
+      n
+    ].join("|");
+  }
+  async postCreateCall(e, t, n) {
+    var c, r, h;
+    const a = await fetch(`${this.backendUrl}/calls/create`, {
+      method: "POST",
+      headers: e,
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        type: ((c = this.runtime) == null ? void 0 : c.callType) || "web",
+        mode: t,
+        ...(r = this.runtime) != null && r.runtimeName ? { runtime: this.runtime.runtimeName } : {},
+        prospect_id: this.prospectId,
+        ...n ? { call_id: n } : {}
+      })
+    });
+    if (!a.ok) {
+      const u = await a.json().catch(() => ({}));
+      throw new Error(`[VaniraClient] createCall failed (${a.status}): ${((h = u == null ? void 0 : u.detail) == null ? void 0 : h.message) || (u == null ? void 0 : u.message) || a.statusText}`);
+    }
+    const i = await a.json();
+    if (!i.call_id || !i.worker_url)
+      throw new Error("[VaniraClient] /calls/create response missing call_id or worker_url");
+    const o = y.normalizeIceServers(i.ice_servers);
+    if (!o.length)
+      throw new Error("[VaniraClient] /calls/create response missing ice_servers");
+    return {
+      callId: i.call_id,
+      prospectId: i.prospect_id || this.prospectId,
+      serverUrl: i.worker_url.replace(/\/$/, ""),
+      iceServers: o
+    };
+  }
+  applyCreateCallSession(e) {
+    if (this.callId = e.callId, this.prospectId = e.prospectId || this.prospectId, this.serverUrl = e.serverUrl, this.iceServers = e.iceServers, this.callSessionLoaded = !0, me(this.agentId, this.callId || "", this.prospectId), this.onSessionStarted && this.prospectId && this.callId && !this.sessionStartedEmitted)
+      try {
+        this.onSessionStarted({ prospectId: this.prospectId, callId: this.callId, serverUrl: this.serverUrl }), this.sessionStartedEmitted = !0;
+      } catch {
+      }
+  }
+  async loadCallSession() {
+    if (this.callSessionLoaded) return;
+    if (this.serverUrl && this.callId) {
+      this.callSessionLoaded = !0;
+      return;
+    }
+    if (!this.apiKey && !this.token)
+      throw new Error("[VaniraClient] apiKey or token is required to create a call session");
+    const e = { "Content-Type": "application/json" };
+    this.apiKey ? e["X-API-Key"] = this.apiKey : this.token && (e.Authorization = this.token.startsWith("Bearer ") ? this.token : `Bearer ${this.token}`);
+    const t = this.sessionBehavior === "continue" ? this.callId : void 0, n = this.sessionBehavior === "continue" ? "continue" : "new", a = this.createCallCacheKey(n, t);
+    let i = y.inflightCreates.get(a);
+    i || (i = this.postCreateCall(e, n, t), y.inflightCreates.set(a, i), i.finally(() => {
+      y.inflightCreates.get(a) === i && y.inflightCreates.delete(a);
+    }));
+    const o = await i;
+    this.applyCreateCallSession(o);
+  }
+  getIceServers() {
+    var e;
+    if ((e = this.iceServers) != null && e.length) return this.iceServers;
+    throw new Error("[VaniraClient] ice_servers missing — pass iceServers from POST /calls/create");
+  }
+  static normalizeIceServers(e) {
+    if (!Array.isArray(e)) return [];
+    const t = [];
+    for (const n of e) {
+      const a = n == null ? void 0 : n.urls, i = Array.isArray(a) ? a.filter(Boolean) : typeof a == "string" && a.trim() ? [a.trim()] : [];
+      if (!i.length) continue;
+      const o = { urls: i.length === 1 ? i[0] : i }, c = n.username, r = n.credential;
+      c && (o.username = c), r && (o.credential = r), t.push(o);
+    }
+    return t;
+  }
+  getWorkerOrigin() {
+    var e;
+    if (!((e = this.serverUrl) != null && e.trim()))
+      return "";
+    try {
+      return new URL(this.serverUrl).origin;
+    } catch {
+      return this.serverUrl.replace(/\/webrtc.*$/, "").replace(/\/$/, "");
+    }
+  }
+  /**
+   * ICE trickle URL derived from worker_url — same host, query params (agent_id, call_id, token), path /webrtc/ice.
+   */
+  getIceTrickleUrl() {
+    try {
+      const e = new URL(this.serverUrl);
+      return e.pathname.endsWith("/webrtc") ? e.pathname = `${e.pathname}/ice` : e.pathname = "/webrtc/ice", e.toString();
+    } catch {
+      return `${this.getWorkerOrigin()}/webrtc/ice?agent_id=${this.agentId}&call_id=${this.callId}`;
+    }
+  }
+  startRemoteIcePolling(e) {
+    this.stopRemoteIcePolling(), this.icePollInterval = setInterval(async () => {
+      if (!this.pc) {
+        this.stopRemoteIcePolling();
+        return;
+      }
+      if (this.pc.connectionState === "connected") {
+        this.stopRemoteIcePolling();
+        return;
+      }
+      try {
+        const t = await fetch(e);
+        if (!t.ok) return;
+        const { candidates: n } = await t.json();
+        for (const a of n || []) {
+          const i = JSON.stringify(a);
+          if (!this.appliedRemoteCandidates.has(i)) {
+            this.appliedRemoteCandidates.add(i);
+            try {
+              await this.pc.addIceCandidate(a);
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }, 150);
+  }
+  stopRemoteIcePolling() {
+    this.icePollInterval !== null && (clearInterval(this.icePollInterval), this.icePollInterval = null);
+  }
+  /**
+   * Send control event via DataChannel
+   */
+  sendEvent(e, t = {}) {
+    var n;
+    if (((n = this.dataChannel) == null ? void 0 : n.readyState) === "open") {
+      const a = { event: e, ...t };
+      this.dataChannel.send(JSON.stringify(a));
+    }
+  }
+  /** Wait for control DataChannel, then send (live vision lifecycle events). */
+  async sendEventWhenReady(e, t = {}, n = 1e4) {
+    var i;
+    const a = Date.now() + n;
+    for (; Date.now() < a; ) {
+      if (((i = this.dataChannel) == null ? void 0 : i.readyState) === "open")
+        return this.sendEvent(e, t), !0;
+      await new Promise((o) => setTimeout(o, 50));
+    }
+    return !1;
+  }
+  /** Open live camera session (sends client_live_camera_started via preset handler). */
+  startLiveCamera(e = {}) {
+    const t = { ...this.liveVision, ...e };
+    this.emit("tool_call", this.buildOpenLiveCameraToolCall(t));
+  }
+  buildOpenLiveCameraToolCall(e = {}) {
+    const t = e.scope ?? "until_call_end";
+    return {
+      name: "open_live_camera",
+      tool_call_id: `lv_${crypto.randomUUID()}`,
+      execution_mode: "fire_and_forget",
+      client_fields: { preset_id: p.LiveVision },
+      arguments: {
+        mode: "live",
+        scope: t,
+        target_fps: e.target_fps ?? 1,
+        max_fps: e.max_fps ?? 3,
+        max_width: e.max_width ?? 640,
+        reason: e.reason ?? "camera_capture",
+        facing_mode: e.facing_mode ?? "environment",
+        show_preview: e.show_preview ?? !0,
+        ...t === "timed" && e.duration_sec ? { duration_sec: e.duration_sec } : {}
+      }
+    };
+  }
+  maybeAutoStartLiveCamera() {
+    const e = this.liveVision;
+    !(e != null && e.enabled) || e.scope !== "full_call" || this.liveVisionAutoStarted || (this.liveVisionAutoStarted = !0, this.emit("tool_call", this.buildOpenLiveCameraToolCall(e)));
+  }
+  /**
+   * Handle control events from server
+   */
+  handleControlEvent(e) {
+    var t;
+    switch (e.event) {
+      case "clearAudio":
+        break;
+      case "transcription":
+        this.onTranscription(e.text, e.isFinal);
+        break;
+      case "mark":
+        break;
+      case "client_tool_cancel": {
+        const a = (e.data || e).tool_call_id || e.tool_call_id;
+        this.dispatchBoardAbort("Tool cancelled by server", a);
+        break;
+      }
+      case "client_tool_call": {
+        const n = e.tool_call || e.data || e, a = (n == null ? void 0 : n.tool_call_id) || (n == null ? void 0 : n.call_id) || e.tool_call_id || "";
+        a && ((t = this.dataChannel) == null ? void 0 : t.readyState) === "open" && this.dataChannel.send(JSON.stringify({
+          event: "client_tool_ack",
+          data: { tool_call_id: a }
+        }));
+        const i = (n == null ? void 0 : n.arguments) || (n == null ? void 0 : n.args) || {}, o = (n == null ? void 0 : n.client_fields) || {}, c = (n == null ? void 0 : n.name) || (n == null ? void 0 : n.tool_name) || "", r = fe(o, i, c);
+        if (c === "end_call") {
+          a && this.sendToolResult(a, {
+            status: "client_ack_end_call",
+            message: "Ending call."
+          }), window.setTimeout(() => this.disconnect(), 120);
+          break;
+        }
+        if (r) {
+          window.dispatchEvent(new CustomEvent("vanira:preset", {
+            detail: { toolCall: n, client: this }
+          })), this.onClientToolCall(n);
+          break;
+        }
+        this.onClientToolCall(n);
+        break;
+      }
+    }
+  }
+  /**
+   * Disconnect and cleanup
+   */
+  disconnect() {
+    var e;
+    this.connectGeneration++, this.stopRemoteIcePolling(), this.appliedRemoteCandidates.clear(), this.audioElement && (this.audioElement.pause(), this.audioElement.srcObject = null), this.dataChannel && (this.dataChannel.close(), this.dataChannel = null), this.mediaBytesChannel && (this.mediaBytesChannel.close(), this.mediaBytesChannel = null), this.pc && (this.pc.getSenders().forEach((t) => {
+      t.track && t.track.stop();
+    }), this.pc.close(), this.pc = null), this.localStream && (this.localStream.getTracks().forEach((t) => {
+      try {
+        t.stop();
+      } catch {
+      }
+    }), this.localStream = null), this.connected = !1, (e = this.routeTracker) == null || e.stop(), this.callSessionLoaded = !1, this.sessionStartedEmitted = !1, this.serverUrl = "", this.callId = void 0, this.micMuted = !1, this.iceServers = void 0, this.onDisconnected();
+  }
+  /**
+   * Mute or unmute the local microphone without tearing down the WebRTC session.
+   * Uses track.enabled (not pause) so audio resumes correctly when unmuted.
+   */
+  setMicrophoneMuted(e) {
+    var t, n;
+    this.micMuted = e, (t = this.localStream) == null || t.getAudioTracks().forEach((a) => {
+      a.enabled = !e;
+    }), (n = this.pc) == null || n.getSenders().forEach((a) => {
+      var i;
+      ((i = a.track) == null ? void 0 : i.kind) === "audio" && (a.track.enabled = !e);
+    });
+  }
+  isMicrophoneMuted() {
+    return this.micMuted;
+  }
+  toggleMicrophoneMuted() {
+    return this.setMicrophoneMuted(!this.micMuted), this.micMuted;
+  }
+  isConnectCancelled(e) {
+    return e !== this.connectGeneration;
+  }
+  /** Notify WidgetPresetRenderer to cancel in-flight board animations */
+  dispatchBoardAbort(e, t) {
+    typeof window > "u" || window.dispatchEvent(new CustomEvent("vanira:board_abort", {
+      detail: { reason: e, toolCallId: t }
+    }));
+  }
+  /**
+   * Send client-side tool execution result back to the AI server.
+   * Use this to unblock a 'blocking' execution mode tool.
+   *
+   * @param toolCallId - `tool_call_id` from the `client_tool_call` event
+   * @param result - Payload returned to the agent
+   */
+  sendToolResult(e, t) {
+    this.callId, this.sendEvent("client_tool_result", {
+      call_id: this.callId,
+      data: { tool_call_id: e, result: t },
+      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 }
+    }));
+  }
+  /**
+   * 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");
+  }
+  /**
+   * Upload file to media server without notifying the AI (no client_media_update).
+   * Use for blocking presets — result goes in client_tool_result only.
+   */
+  async uploadMediaForToolResult(e, t = "general") {
+    return this._postMediaUpload(e, t);
+  }
+  /**
+   * 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 = "") {
+    return await ye(this.dataChannel, this.mediaBytesChannel) ? this._uploadMediaViaDataChannel(e, t, n) : (Se(this.dataChannel, this.mediaBytesChannel), this._uploadMediaViaHTTP(e, t, n));
+  }
+  /**
+   * Upload a live vision / screen frame — HTTP only for now, never sends client_media_update.
+   * Caller sends client_media_frame after this returns.
+   *
+   * Frames require a real media_url (server rejects empty). WebRTC upload returns url="" until
+   * the server adds client_media_upload_ready ack — use HTTP for frame JPEGs until then.
+   */
+  async uploadMediaFrame(e, t = "camera_capture", n) {
+    const a = n && !(e instanceof File) ? new File([e], n, { type: e.type || "image/jpeg" }) : e, { media_id: i, url: o, contentType: c } = await this._postMediaUpload(a, t, !0);
+    if (!i || !o)
+      throw new Error("Frame upload failed: server response missing media_id or url");
+    return { media_id: i, url: o, content_type: c };
+  }
+  /** WebRTC media-bytes path (control start/complete + binary chunks). */
+  async _uploadBytesViaDataChannel(e, t, n, a, i) {
+    if (!this.callId || !this.mediaBytesChannel)
+      throw new Error("Upload failed: call not ready for WebRTC media upload.");
+    const o = i || (e instanceof File ? e.name : a === "frame" ? "frame.jpg" : "upload.bin"), c = e.type || (a === "frame" ? "image/jpeg" : "application/octet-stream"), r = await ge(e);
+    return ve({
+      bytes: r,
+      filename: o,
+      contentType: c,
+      reason: t,
+      message: n,
+      callId: this.callId,
+      mediaBytesChannel: this.mediaBytesChannel,
+      sendControlEvent: (h, u) => this.sendEvent(h, u),
+      uploadKind: a
+    });
+  }
+  async _uploadMediaViaDataChannel(e, t, n) {
+    const a = await this._uploadBytesViaDataChannel(e, t, n, "media");
+    return { media_id: a.media_id, url: a.url };
+  }
+  /** HTTP fallback — original uploadMedia behavior (unchanged). */
+  async _uploadMediaViaHTTP(e, t = "general", n = "") {
+    const { media_id: a, url: i, contentType: o } = await this._postMediaUpload(e, t, !0);
+    if (this.dataChannel && this.dataChannel.readyState === "open") {
+      const c = {
+        event: "client_media_update",
+        data: {
+          media_id: a,
+          media_url: i,
+          content_type: o,
+          reason: t,
+          message: n
+        }
+      };
+      this.dataChannel.send(JSON.stringify(c));
+    }
+    return { media_id: a, url: i };
+  }
+  async _postMediaUpload(e, t, n = !1) {
+    if (!this.serverUrl)
+      throw new Error("Upload failed: serverUrl is not set. Connect the VaniraClient first.");
+    if (!this.callId)
+      throw new Error("Upload failed: callId is missing.");
+    const a = this.getWorkerOrigin();
+    if (!a)
+      throw new Error(
+        "Upload failed: worker_url is not set. Connect the call before uploading media."
+      );
+    const i = `${a}/media/upload`, o = new FormData();
+    o.append("file", e), o.append("call_id", this.callId), o.append("reason", t);
+    const c = await fetch(i, {
+      method: "POST",
+      body: o
+    });
+    if (!c.ok) {
+      let _ = `HTTP ${c.status}`;
+      try {
+        _ = (await c.json()).error || _;
+      } catch {
+      }
+      throw new Error(`Upload failed: ${_}`);
+    }
+    const r = await c.json(), h = r.media_id, u = r.url, d = r.content_type || e.type;
+    if (!h || !u)
+      throw new Error("Upload failed: server response missing media_id or url");
+    return n ? { media_id: h, url: u, contentType: d } : { media_id: h, url: u, contentType: d };
+  }
+  // ─── Event emitter (replaces retired VaniraAI) ───────────────────────────
+  get status() {
+    return this._status;
+  }
+  get isConnected() {
+    return this._status === "connected";
+  }
+  on(e, t) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), this;
+  }
+  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((a) => a(t));
+  }
+  /** Alias for connect() — VaniraAI compatibility */
+  async start() {
+    return await this.connect(), {
+      callId: this.callId || "",
+      prospectId: this.prospectId || "",
+      serverUrl: this.serverUrl || ""
+    };
+  }
+  /** Alias for disconnect() — VaniraAI compatibility */
+  stop() {
+    this.disconnect(), this._status = "disconnected";
+  }
+  sendToolError(e, t) {
+    this.sendToolResult(e, { status: "error", error: t });
+  }
+  /** @deprecated Use sendContextUpdate */
+  updateContext(e) {
+    this.sendContextUpdate(e);
+  }
+  /** @deprecated Use triggerActionInterrupt + sendActionTrigger */
+  triggerInterrupt(e, t = {}) {
+    this.triggerActionInterrupt(), this.sendActionTrigger(e, t);
+  }
+  interruptAudioOnly() {
+    this.triggerActionInterrupt();
+  }
+};
+/** Dedupes concurrent POST /calls/create (e.g. React StrictMode double-mount). */
+l(y, "inflightCreates", /* @__PURE__ */ new Map());
+let N = y;
+var F;
+const be = {
+  supportsAudioEndedEvent: !0,
+  supportsScreenShare: typeof navigator < "u" && typeof ((F = navigator.mediaDevices) == null ? void 0 : F.getDisplayMedia) == "function",
+  supportsDom: typeof document < "u",
+  supportsHtmlAudio: typeof Audio < "u",
+  supportsCustomElements: typeof customElements < "u",
+  supportsLocalStorage: typeof localStorage < "u",
+  supportsBroadcastChannel: typeof BroadcastChannel < "u"
+}, Te = {
+  name: "browser",
+  callType: "web",
+  runtimeName: "browser",
+  callIdPrefix: "web_",
+  capabilities: be,
+  audio: new se(),
+  media: new re(),
+  peer: new oe(),
+  dataChannel: new le()
+};
+function Ee(s) {
+  return new N({
+    ...s,
+    runtime: Te
+  });
+}
+const Re = Ee, b = class b {
+  constructor(e) {
+    l(this, "tabId");
+    l(this, "sessionKey");
+    l(this, "channelName");
+    l(this, "channel", null);
+    l(this, "heartbeatTimer", null);
+    l(this, "listeners", /* @__PURE__ */ new Map());
+    const t = e.replace(/[^a-z0-9_-]/gi, "_");
+    this.sessionKey = `vaniraai_session_${t}`, this.channelName = `vaniraai_channel_${t}`, this.tabId = this._getOrCreateTabId(), this._setupChannel();
+  }
+  // ─── Public API ──────────────────────────────────────────────────────────
+  /** Returns this tab's unique ID (stable across same-tab page refreshes). */
+  getTabId() {
+    return this.tabId;
+  }
+  /**
+   * Try to claim the session for this tab.
+   * Returns true  → session claimed (or restored after stale prior tab).
+   * Returns false → another live tab already owns the session.
+   */
+  claimSession() {
+    const e = this._loadSession();
+    if (e) {
+      const a = Date.now() - e.lastActive, i = e.tabId === this.tabId, o = a > b.HEARTBEAT_TIMEOUT_MS;
+      if (i)
+        return this._startHeartbeat(), this._emit("session_restored"), !0;
+      if (!o)
+        return this._emit("tab_conflict"), !1;
+    }
+    const t = e ? { ...e, tabId: this.tabId, lastActive: Date.now() } : { tabId: this.tabId, prospectId: "", chatId: null, conversationId: null, messages: [], lastActive: Date.now() };
+    this._saveSession(t), this._startHeartbeat(), this._broadcast({ type: "took_over", tabId: this.tabId });
+    const n = !!(e != null && e.prospectId);
+    return this._emit(n ? "session_restored" : "session_claimed"), !0;
+  }
+  /**
+   * Force-claim the session even if another tab owns it.
+   * Call this when the user explicitly clicks "Use here" in the conflict UI.
+   */
+  forceClaimSession() {
+    const e = this._loadSession(), t = e ? { ...e, tabId: this.tabId, lastActive: Date.now() } : { tabId: this.tabId, prospectId: "", chatId: null, conversationId: null, messages: [], lastActive: Date.now() };
+    this._saveSession(t), this._startHeartbeat(), this._broadcast({ type: "took_over", tabId: this.tabId }), this._emit("session_claimed");
+  }
+  /** Save / update the prospect and chat IDs for this session. */
+  saveIds(e, t, n) {
+    const a = this._loadSession() ?? this._blankSession();
+    this._saveSession({ ...a, prospectId: e, chatId: t, conversationId: n ?? a.conversationId ?? null, tabId: this.tabId, lastActive: Date.now() });
+  }
+  /** Append a message to the persisted history. */
+  pushMessage(e, t) {
+    const n = this._loadSession() ?? this._blankSession();
+    n.messages.push({ role: e, content: t, timestamp: Date.now() }), n.messages.length > 100 && (n.messages = n.messages.slice(-100)), this._saveSession({ ...n, tabId: this.tabId, lastActive: Date.now() });
+  }
+  /** Update the content of the last assistant message (streaming). */
+  updateLastAssistantMessage(e) {
+    const t = this._loadSession() ?? this._blankSession(), n = t.messages;
+    let a = !1;
+    for (let i = n.length - 1; i >= 0; i--)
+      if (n[i].role === "assistant" && n[i].content === "") {
+        n[i].content = e, a = !0;
+        break;
+      }
+    if (!a) {
+      for (let i = n.length - 1; i >= 0; i--)
+        if (n[i].role === "assistant") {
+          n[i].content = e, a = !0;
+          break;
+        }
+    }
+    a || n.push({ role: "assistant", content: e, timestamp: Date.now() }), this._saveSession({ ...t, tabId: this.tabId, lastActive: Date.now() });
+  }
+  /** Returns the currently persisted session data (null if none). */
+  getSession() {
+    return this._loadSession();
+  }
+  /** Clears ALL session data (prospect_id, chat_id, messages). */
+  clearSession() {
+    localStorage.removeItem(this.sessionKey), this._broadcast({ type: "session_cleared", tabId: this.tabId }), this._emit("session_cleared");
+  }
+  /** Clears chat-specific session data (chatId, conversationId, messages) but keeps the prospectId. */
+  clearChatKeepProspect() {
+    const e = this._loadSession();
+    e && this._saveSession({
+      ...e,
+      chatId: null,
+      conversationId: null,
+      messages: [],
+      lastActive: Date.now()
+    });
+  }
+  /** Stop the heartbeat and release resources. Call on widget destroy. */
+  destroy() {
+    this._stopHeartbeat(), this.channel && (this.channel.close(), this.channel = null);
+  }
+  // ─── Event Emitter ───────────────────────────────────────────────────────
+  on(e, t) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), this;
+  }
+  off(e, t) {
+    var n;
+    return (n = this.listeners.get(e)) == null || n.delete(t), this;
+  }
+  // ─── Private ─────────────────────────────────────────────────────────────
+  _getOrCreateTabId() {
+    let e = sessionStorage.getItem("vaniraai_tab_id");
+    return e || (e = `tab_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`, sessionStorage.setItem("vaniraai_tab_id", e)), e;
+  }
+  _setupChannel() {
+    typeof BroadcastChannel > "u" || (this.channel = new BroadcastChannel(this.channelName), this.channel.onmessage = (e) => {
+      const t = e.data;
+      t.tabId !== this.tabId && (t.type === "took_over" && (this._stopHeartbeat(), this._emit("tab_took_over")), t.type, t.type === "session_cleared" && this._emit("session_cleared"));
+    });
+  }
+  _broadcast(e) {
+    var t;
+    (t = this.channel) == null || t.postMessage(e);
+  }
+  _startHeartbeat() {
+    this._stopHeartbeat(), this.heartbeatTimer = setInterval(() => {
+      const e = this._loadSession();
+      e && e.tabId === this.tabId && (this._saveSession({ ...e, lastActive: Date.now() }), this._broadcast({ type: "heartbeat", tabId: this.tabId }));
+    }, b.HEARTBEAT_INTERVAL_MS);
+  }
+  _stopHeartbeat() {
+    this.heartbeatTimer !== null && (clearInterval(this.heartbeatTimer), this.heartbeatTimer = null);
+  }
+  _loadSession() {
+    try {
+      const e = localStorage.getItem(this.sessionKey);
+      return e ? JSON.parse(e) : null;
+    } catch {
+      return null;
+    }
+  }
+  _saveSession(e) {
+    try {
+      localStorage.setItem(this.sessionKey, JSON.stringify(e));
+    } catch {
+    }
+  }
+  _blankSession() {
+    return {
+      tabId: this.tabId,
+      prospectId: "",
+      chatId: null,
+      conversationId: null,
+      messages: [],
+      lastActive: Date.now()
+    };
+  }
+  _emit(e) {
+    var t;
+    (t = this.listeners.get(e)) == null || t.forEach((n) => n());
+  }
+};
+/** How often (ms) the active tab broadcasts its heartbeat */
+l(b, "HEARTBEAT_INTERVAL_MS", 5e3), /** How old (ms) a heartbeat must be before we consider the tab dead */
+l(b, "HEARTBEAT_TIMEOUT_MS", 15e3);
+let q = b;
+class Pe {
+  static async fetchWidgetConfig(e, t) {
+    var a;
+    const n = { "Content-Type": "application/json" };
+    t && (n["X-API-Key"] = t);
+    try {
+      const i = await fetch(`${V}/assistant/widget/${e}/config`, {
+        method: "GET",
+        headers: n
+      });
+      if (!i.ok)
+        throw new Error(`Widget config fetch failed: HTTP ${i.status}`);
+      const o = await i.json();
+      return (a = o.agent) != null && a.client && (o.client = o.agent.client), o;
+    } catch (i) {
+      throw i;
+    }
+  }
+}
+let A = "https://inboxapi.vanira.io";
+const ke = "https://coredb.travelr.club/v1/graphql";
+class Oe {
+  static setChatUrl(e) {
+    A = e;
+  }
+  static async createChatProspect(e) {
+    var n, a;
+    const t = `
+        mutation CreateChatProspect($prospectGroupId: uuid!, $name: String!) {
+          insert_prospects_one(object: {prospect_group_id: $prospectGroupId, name: $name, source: WEBSITE_WIDGET}) {
+            id
+          }
+        }
+      `;
+    try {
+      const o = await (await fetch(ke, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          query: t,
+          variables: {
+            prospectGroupId: e,
+            name: `Widget Guest ${(/* @__PURE__ */ new Date()).toLocaleString()}`
+          }
+        })
+      })).json();
+      return o.errors ? `anon_${Date.now()}_${Math.random().toString(36).substr(2, 9)}` : ((a = (n = o.data) == null ? void 0 : n.insert_prospects_one) == null ? void 0 : a.id) || `anon_${Date.now()}`;
+    } catch {
+      return `anon_${Date.now()}`;
+    }
+  }
+  // Calls the new Go bridge /widget/chat endpoint with an empty message to initialize the session and get the Welcome config + inbox_id
+  static async fetchWelcomeMessage(e, t, n, a) {
+    try {
+      const i = { "Content-Type": "application/json" }, o = await fetch(`${A}/widget/chat`, {
+        method: "POST",
+        headers: i,
+        body: JSON.stringify({
+          agent_id: e,
+          ...n ? { widget_id: n } : {},
+          message: "",
+          prospect_id: t,
+          stream: !1
+        })
+      });
+      if (!o.ok) throw new Error("Failed to fetch welcome message");
+      const c = await o.json();
+      let r = c.response || "Hey! how can I help you ?", h;
+      const u = c.chat_id || c.inbox_id, d = c.conversation_id || null;
+      return c.widget && (h = c.widget), { role: "assistant", content: r, widget: h, chatId: u, conversationId: d };
+    } catch {
+      return { role: "assistant", content: "Hey! how can I help you ?" };
+    }
+  }
+  static async sendChatMessage(e, t, n, a, i, o, c, r, h) {
+    var u, d, _, f;
+    try {
+      const m = { "Content-Type": "application/json" }, S = {
+        agent_id: e,
+        message: n,
+        prospect_id: t,
+        stream: !0
+      };
+      a && (S.inbox_id = a), r && (S.widget_id = r);
+      const T = await fetch(`${A}/widget/chat`, {
+        method: "POST",
+        headers: m,
+        body: JSON.stringify(S)
+      });
+      if (!T.ok) throw new Error("Chat request failed");
+      const E = (u = T.body) == null ? void 0 : u.getReader(), R = new TextDecoder();
+      if (!E) throw new Error("No reader");
+      let k = "", I = "", v = null, g = null;
+      for (; ; ) {
+        const { done: P, value: ee } = await E.read();
+        if (P) break;
+        I += R.decode(ee, { stream: !0 });
+        const j = I.split(`
+`);
+        I = j.pop() || "";
+        for (const te of j) {
+          const L = te.trim();
+          if (L && L.startsWith("data: ")) {
+            const H = L.slice(6);
+            if (H === "[DONE]") {
+              c(v, g);
+              return;
+            }
+            try {
+              const w = JSON.parse(H);
+              if (w.type === "metadata") {
+                (w.chat_id || w.inbox_id) && (v = w.chat_id || w.inbox_id), w.conversation_id && (g = w.conversation_id);
+                continue;
+              }
+              const K = (f = (_ = (d = w.choices) == null ? void 0 : d[0]) == null ? void 0 : _.delta) == null ? void 0 : f.content;
+              K && (k += K, i(k)), w.widget && o(w.widget), w.chat_id && !v && (v = w.chat_id), w.conversation_id && !g && (g = w.conversation_id);
+            } catch {
+            }
+          }
+        }
+      }
+      c(v, g);
+    } catch {
+      i("Sorry, I encountered an error. Please try again."), c(null, null);
+    }
+  }
+  static listenForAdminReplies(e, t, n) {
+    const a = `${A}/inbox/stream?inbox_id=${e}&sender=${encodeURIComponent(t)}`;
+    let i = null, o = 0, c = !1;
+    const r = () => {
+      c || (i = new EventSource(a), i.onopen = () => {
+        o = 0;
+      }, i.onmessage = (h) => {
+        try {
+          const u = JSON.parse(h.data), d = u.direction === "outgoing", _ = !!u.content, f = u.source !== "ai";
+          d && _ && f && n(u.content);
+        } catch {
+        }
+      }, i.onerror = (h) => {
+        if (i && (i.close(), i = null), c) return;
+        const u = Math.min(2e3 * Math.pow(2, o), 3e4);
+        o++, setTimeout(r, u);
+      });
+    };
+    return r(), {
+      close: () => {
+        c = !0, i && (i.close(), i = null);
+      }
+    };
+  }
+  static async createCall(e, t, n, a, i) {
+    try {
+      const o = { "Content-Type": "application/json" };
+      i && (o["X-API-Key"] = i);
+      const c = await fetch(`${V}/calls/create`, {
+        method: "POST",
+        headers: o,
+        body: JSON.stringify({
+          agent_id: e,
+          prospect_id: n || void 0,
+          type: "web"
+        })
+      }), r = await c.json();
+      if (!c.ok)
+        throw new Error(`[VaniraAI] Call creation failed HTTP ${c.status}`);
+      if (!r.worker_url)
+        throw new Error("[VaniraAI] Worker URL missing from response. Call cannot proceed.");
+      return {
+        callId: r.call_id || r.id || `web_${Date.now()}`,
+        workerUrl: r.worker_url
+        // Pass the full authenticated URL
+      };
+    } catch (o) {
+      throw o;
+    }
+  }
+  static async resolveConversation(e) {
+    try {
+      if (!(await fetch(`${A}/inbox/conversations/resolve`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ conversation_id: e })
+      })).ok) throw new Error("Failed to resolve conversation");
+    } catch (t) {
+      throw t;
+    }
+  }
+}
+export {
+  se as BrowserAudioAdapter,
+  le as BrowserDataChannelAdapter,
+  re as BrowserMediaAdapter,
+  oe as BrowserPeerAdapter,
+  Oe as ChatService,
+  Pe as ConfigService,
+  q as SessionManager,
+  N as VaniraAI,
+  N as VaniraClient,
+  N as WebRTCClient,
+  be as browserCapabilities,
+  Te as browserRuntime,
+  Re as createBrowserAI,
+  Ee as createBrowserClient
+};