@osvi-ai/chat 0.0.0-stage → 0.1.0

package/dist/index-BsRyQwUM.js

@@ -0,0 +1,1331 @@
+const nt = "0.1.0", rt = /* @__PURE__ */ new Set([
+  "origin_not_allowed",
+  "agent_inactive",
+  "agent_archived",
+  "agent_not_found",
+  "session_not_found",
+  "session_closed",
+  "invalid_customer_id",
+  "invalid_token",
+  "session_unavailable",
+  "stream_unavailable",
+  "token_failed",
+  "rate_limited",
+  "network",
+  "interaction_not_pending",
+  "interaction_suspended",
+  "invalid_interaction",
+  "unknown"
+]), ot = /* @__PURE__ */ new Set(["rate_limited", "network", "session_unavailable", "stream_unavailable", "token_failed"]);
+function f(i, t) {
+  const e = i && rt.has(i) ? i : "unknown";
+  return { code: e, message: t || e, retryable: ot.has(e) };
+}
+class m extends Error {
+  constructor(t, e) {
+    super(t.message), this.error = t, this.status = e, this.name = "ChatRequestError";
+  }
+}
+const at = 3e5;
+function X(i, t = Date.now()) {
+  return typeof i != "number" || !Number.isFinite(i) ? t + at : i < 1e12 ? i * 1e3 : i;
+}
+class ct {
+  constructor(t, e = (...s) => globalThis.fetch.bind(globalThis)(...s)) {
+    this.fetchImpl = e, this.base = t.replace(/\/+$/, "");
+  }
+  resolveUrl(t) {
+    return `${this.base}${t}`;
+  }
+  bootstrap(t, e, s) {
+    const n = `?customer_id=${encodeURIComponent(e)}`;
+    return this.request(`/public/chat/agents/${encodeURIComponent(t)}/bootstrap${n}`, { signal: s });
+  }
+  createSession(t, e) {
+    return this.request(`/public/chat/agents/${encodeURIComponent(t)}/session`, {
+      method: "POST",
+      body: JSON.stringify({ customer_id: e })
+    });
+  }
+  async mintPublicToken(t) {
+    const e = await this.request(
+      `/public/chat/session/${encodeURIComponent(t)}/ws_token`,
+      { method: "POST", body: "{}" }
+    );
+    if (!e?.token || !e?.ws_url) throw new m(f("stream_unavailable"), 200);
+    return { token: e.token, wsUrl: e.ws_url, expiresAt: X(e.expires_at) };
+  }
+  snapshot(t, e) {
+    return this.request(`/public/chat/session/${encodeURIComponent(t)}/snapshot`, {
+      headers: { Authorization: `Bearer ${e}` }
+    });
+  }
+  async request(t, e = {}) {
+    let s;
+    try {
+      const r = this.fetchImpl, o = { ...e.headers };
+      e.body !== void 0 && (o["Content-Type"] = "application/json"), s = await r(this.resolveUrl(t), { ...e, credentials: "omit", headers: o });
+    } catch (r) {
+      throw r?.name === "AbortError" ? r : new m(f("network", "Network error"), 0);
+    }
+    let n = null;
+    try {
+      n = await s.json();
+    } catch {
+      n = null;
+    }
+    if (!s.ok || n?.success === !1) {
+      const r = f(
+        typeof n?.error == "string" ? n.error : void 0,
+        typeof n?.message == "string" ? n.message : void 0
+      );
+      if (typeof n?.origin == "string" && (r.origin = n.origin), s.status === 429) {
+        r.code = "rate_limited", r.retryable = !0;
+        const o = Number(s.headers.get("Retry-After")), a = Number(n?.retry_after), h = Number.isFinite(o) && o > 0 ? o : a;
+        Number.isFinite(h) && h > 0 && (r.retryAfterSeconds = h);
+      }
+      throw new m(r, s.status);
+    }
+    return n?.data ?? n;
+  }
+}
+const $ = [
+  { tool_type: "ui_buttons", schema_version: 1 },
+  { tool_type: "ui_buttons", schema_version: 2 },
+  { tool_type: "ui_carousel", schema_version: 1 },
+  { tool_type: "ui_date_picker", schema_version: 1 }
+], ht = 65536, dt = 2e3, lt = 8192, B = 2048, j = /^[A-Za-z0-9_-]{1,64}$/, w = (i) => !!i && typeof i == "object" && !Array.isArray(i), S = (i, t) => Object.keys(i).every((e) => t.includes(e)), ut = (i) => [...i].length, Q = (i) => new TextEncoder().encode(i).length, pt = (i) => [...i].some((t) => {
+  const e = t.codePointAt(0) ?? 0;
+  return e === 127 || e < 32 && e !== 9 && e !== 10 && e !== 13;
+}), ft = (i) => [...i].some((t) => {
+  const e = t.codePointAt(0) ?? 0;
+  return e <= 32 || e === 127;
+}), g = (i, t, e = !1) => typeof i == "string" && ut(i) <= t && !pt(i) && (!e || i.trim().length > 0), V = (i) => Array.isArray(i) ? i.map(V) : w(i) ? Object.fromEntries(Object.keys(i).sort().map((t) => [t, V(i[t])])) : i, G = (i) => {
+  try {
+    return Q(JSON.stringify(V(i))) <= ht;
+  } catch {
+    return !1;
+  }
+};
+function gt(i) {
+  return typeof i == "string" && /^\/public\/chat\/images\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/(?:0|[1-9][0-9]*)$/i.test(i);
+}
+function mt(i) {
+  if (typeof i != "string" || i.length === 0 || i.length > B || ft(i)) return !1;
+  try {
+    const t = new URL(i), e = t.hostname.toLowerCase();
+    return t.protocol !== "https:" || t.username || t.password || t.hash || t.port || !e || e === "localhost" || e.endsWith(".localhost") || e.endsWith(".local") || e.endsWith(".internal") || e.startsWith("[") || /^\d{1,3}(?:\.\d{1,3}){3}$/.test(e) ? !1 : t.toString().length <= B;
+  } catch {
+    return !1;
+  }
+}
+function O(i, t) {
+  if (!w(i) || !S(i, ["label", "description", "options"]) || !g(i.label, 160, !0) || "description" in i && i.description !== void 0 && !g(i.description, 240) || !Array.isArray(i.options) || i.options.length === 0 || t !== void 0) return !1;
+  const e = /* @__PURE__ */ new Set();
+  let s = 0;
+  for (const n of i.options) {
+    if (!w(n) || !S(n, ["id", "label", "description", "allow_input", "input_placeholder"]) || typeof n.id != "string" || !j.test(n.id) || e.has(n.id) || !g(n.label, 80, !0) || "description" in n && n.description !== void 0 && !g(n.description, 240)) return !1;
+    const r = n.allow_input === !0;
+    if ("allow_input" in n && !r || "input_placeholder" in n && (!r || !g(n.input_placeholder, 160, !0)) || (r && (s += 1), s > 1)) return !1;
+    e.add(n.id);
+  }
+  return G(i);
+}
+function Z(i, t) {
+  return O(i, t) && i.options.every((e) => !Object.prototype.hasOwnProperty.call(e, "allow_input") && !Object.prototype.hasOwnProperty.call(e, "input_placeholder"));
+}
+function tt(i, t, e = !1) {
+  if (!w(i) || !S(i, ["label", "description", "items"]) || !g(i.label, 160, !0) || "description" in i && i.description !== void 0 && !g(i.description, 240) || !Array.isArray(i.items) || i.items.length === 0 || t !== void 0) return !1;
+  const s = /* @__PURE__ */ new Set();
+  for (const n of i.items) {
+    if (!w(n) || !S(n, ["id", "title", "description", "image", "action_label"]) || typeof n.id != "string" || !j.test(n.id) || s.has(n.id) || !g(n.title, 120, !0) || "description" in n && n.description !== void 0 && !g(n.description, 500) || "action_label" in n && n.action_label !== void 0 && !g(n.action_label, 80, !0) || "image" in n && n.image !== void 0 && (!w(n.image) || !S(n.image, ["url", "alt"]) || !(mt(n.image.url) || e && gt(n.image.url)) || !g(n.image.alt, 240, !0)))
+      return !1;
+    s.add(n.id);
+  }
+  return G(i);
+}
+function P(i) {
+  if (typeof i != "string" || !/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/.test(i)) return !1;
+  const t = Number(i.slice(0, 4)), e = Number(i.slice(5, 7)), s = Number(i.slice(8, 10));
+  if (t < 1 || t > 9999 || e < 1 || e > 12 || s < 1) return !1;
+  const r = [31, t % 4 === 0 && (t % 100 !== 0 || t % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return s <= r[e - 1];
+}
+function L(i) {
+  return !w(i) || !S(i, ["label", "description", "min_date", "max_date", "confirm_label", "selection_mode"]) || !g(i.label, 160, !0) || !["single", "range"].includes(String(i.selection_mode)) || "description" in i && i.description !== void 0 && !g(i.description, 240) || "confirm_label" in i && i.confirm_label !== void 0 && !g(i.confirm_label, 80, !0) || "min_date" in i && i.min_date !== void 0 && !P(i.min_date) || "max_date" in i && i.max_date !== void 0 && !P(i.max_date) || typeof i.min_date == "string" && typeof i.max_date == "string" && i.min_date > i.max_date ? !1 : G(i);
+}
+function $t(i, t) {
+  return i.tool_type === "ui_buttons" && i.schema_version === 1 ? Z(t) : i.tool_type === "ui_buttons" && i.schema_version === 2 ? O(t) : i.tool_type === "ui_carousel" && i.schema_version === 1 ? tt(t, void 0, !0) : i.tool_type === "ui_date_picker" && i.schema_version === 1 ? L(t) : !1;
+}
+function et(i, t) {
+  return !w(t) || !S(t, ["kind", "value"]) || Object.keys(t).length !== 2 ? !1 : t.kind === "date_range" ? i.tool_type === "ui_date_picker" && i.schema_version === 1 && w(t.value) && S(t.value, ["start_date", "end_date"]) && Object.keys(t.value).length === 2 && P(t.value.start_date) && P(t.value.end_date) && t.value.start_date < t.value.end_date : typeof t.value != "string" ? !1 : t.kind === "selection" ? (i.tool_type === "ui_buttons" || i.tool_type === "ui_carousel") && j.test(t.value) : t.kind === "text" ? i.tool_type === "ui_buttons" && i.schema_version === 2 && t.value === t.value.trim() && g(t.value, dt, !0) && Q(t.value) <= lt : t.kind === "date" ? i.tool_type === "ui_date_picker" && i.schema_version === 1 && P(t.value) : !1;
+}
+const W = (i) => i !== null && typeof i == "object" && !Array.isArray(i), _t = /* @__PURE__ */ new Set(["preparing", "pending", "accepted", "resumed", "cancelled", "expired"]);
+function b(i) {
+  if (!W(i) || i.type !== "interaction" || typeof i.id != "string" || !i.id || i.role !== "assistant" || typeof i.content != "string" || typeof i.interaction_id != "string" || !i.interaction_id || typeof i.tool_type != "string" || !Number.isSafeInteger(i.schema_version) || Number(i.schema_version) < 1 || !Number.isSafeInteger(i.interaction_revision) || Number(i.interaction_revision) < 1 || !_t.has(String(i.interaction_status)) || !W(i.presentation)) return null;
+  const t = { tool_type: i.tool_type, schema_version: Number(i.schema_version) }, e = i.response_payload;
+  return e != null && !et(t, e) ? null : {
+    id: i.id,
+    type: "interaction",
+    role: "assistant",
+    content: i.content,
+    interaction_id: i.interaction_id,
+    tool_type: i.tool_type,
+    schema_version: Number(i.schema_version),
+    presentation: i.presentation,
+    interaction_status: i.interaction_status,
+    interaction_revision: Number(i.interaction_revision),
+    ...typeof i.created_at == "string" ? { created_at: i.created_at } : {},
+    ...typeof i.selected_option_id == "string" ? { selected_option_id: i.selected_option_id } : {},
+    ...e !== void 0 ? { response_payload: e } : {}
+  };
+}
+function y(i) {
+  if (!W(i) || typeof i.id != "string" && typeof i.id != "number" || typeof i.content != "string" || !["assistant", "user", "operator", "system"].includes(String(i.role))) return null;
+  const t = b({ ...i, id: String(i.id) });
+  return {
+    id: String(i.id),
+    content: i.content,
+    type: i.type === "interaction" ? "interaction" : "message",
+    ts: typeof i.created_at == "string" ? i.created_at : typeof i.ts == "string" ? i.ts : (/* @__PURE__ */ new Date()).toISOString(),
+    ...t ?? {},
+    role: i.role
+  };
+}
+function R(i) {
+  return typeof i == "string" && /^\d+$/.test(i) ? i.replace(/^0+(?=\d)/, "") : null;
+}
+function k(i, t) {
+  return i.length === t.length ? i === t ? 0 : i > t ? 1 : -1 : i.length > t.length ? 1 : -1;
+}
+function M(i, t) {
+  const e = [...i];
+  for (const s of t) {
+    const n = e.findIndex((r) => r.id === s.id || s.interaction_id && r.interaction_id === s.interaction_id);
+    if (n < 0) e.push(s);
+    else {
+      const r = e[n], o = (h) => h.interaction_status === "preparing" ? 0 : h.interaction_status === "pending" ? 1 : h.interaction_status === "accepted" ? 2 : 3;
+      !(s.interaction_revision === r.interaction_revision && o(s) < o(r)) && (!s.interaction_revision || !r.interaction_revision || s.interaction_revision >= r.interaction_revision) && (e[n] = { ...r, ...s });
+    }
+  }
+  return e;
+}
+const yt = /* @__PURE__ */ new Set(["user", "ai", "assistant", "operator", "support", "system"]);
+function N(i) {
+  if (!i || typeof i != "object") return null;
+  const t = i, e = typeof t.id == "number" ? String(t.id) : t.id;
+  if (typeof e != "string" || e === "" || typeof t.content != "string" || typeof t.role != "string" || !yt.has(t.role)) return null;
+  const s = { id: e, role: t.role, content: t.content };
+  return typeof t.created_at == "string" && (s.created_at = t.created_at), (t.type === "interaction" || t.type === "message") && (s.type = t.type), s;
+}
+const v = (i) => ["pending", "accepted"].includes(i.interaction_status);
+class wt {
+  constructor(t) {
+    this.host = t, this._active = null, this._cursor = "0", this._pending = !1, this._error = null, this.operations = /* @__PURE__ */ new Map(), this.operation = null, this.generation = 0, this.refreshInFlight = !1, this.recoveryCursor = null;
+  }
+  get active() {
+    return this._active;
+  }
+  get cursor() {
+    return this._cursor;
+  }
+  get pending() {
+    return this._pending;
+  }
+  get error() {
+    return this._error;
+  }
+  setActive(t) {
+    this._active = t, this.host.onChange();
+  }
+  setCursor(t) {
+    this._cursor = t, this.host.onChange();
+  }
+  setSelectionPending(t) {
+    this._pending = t, this.host.onChange();
+  }
+  setInteractionError(t) {
+    this._error = t, this.host.onChange();
+  }
+  setRows(t) {
+    this.host.updateItems((e) => {
+      let s = e.length;
+      for (; s > 0 && e[s - 1].kind !== "divider"; ) s -= 1;
+      const n = e.slice(s);
+      return [...e.slice(0, s), ...kt(t(St(n)), n)];
+    });
+  }
+  reset() {
+    this.generation += 1, this.refreshInFlight = !1, this.recoveryCursor = null, this.setActive(null), this._cursor = "0", this.setCursor("0"), this.operations.clear(), this.operation = null, this.setSelectionPending(!1), this.setInteractionError(null);
+  }
+  reject(t, e) {
+    this.operations.delete(t.interactionId), this.operations.size === 0 && (this.recoveryCursor = null), this.operation === t && (this.operation = null), this.setSelectionPending(!1), this.setInteractionError(e);
+    const s = this._active, n = s?.interaction_id === t.interactionId && s.interaction_revision <= t.original.interaction_revision;
+    n && this.setActive(t.original), this.setRows((r) => r.filter((o) => o.id !== t.messageId).map((o) => n && o.interaction_id === t.interactionId ? y(t.original) : o));
+  }
+  mergeProjection(t, e) {
+    const s = y(e), n = t && this.operations.get(t.interaction_id);
+    n && s?.role === "user" && (this.operations.delete(n.interactionId), this.operations.size === 0 && (this.recoveryCursor = null), this.operation === n && (this.operation = null), this.setSelectionPending(!1), this.setInteractionError(null));
+    const r = [t && y(t), s?.role === "user" ? s : null].filter((o) => o !== null);
+    this.setRows((o) => {
+      const a = n && s?.role === "user" && o.some((h) => h.id === n.messageId) ? o.flatMap((h) => h.id === n.messageId ? [s] : h.id === s.id ? [] : [h]) : o;
+      return M(a, r);
+    });
+  }
+  refreshMissingOutcome(t) {
+    if (this.operations.size === 0) {
+      this.recoveryCursor = null;
+      return;
+    }
+    if ((this.recoveryCursor === null || k(t, this.recoveryCursor) > 0) && (this.recoveryCursor = t), this.refreshInFlight) return;
+    const e = this.recoveryCursor, s = [...this.operations.values()], n = (a) => this.operations.get(a.interactionId) === a, r = this.generation, o = this.host.sessionId();
+    this.refreshInFlight = !0, this.setSelectionPending(!0), this.host.refreshSnapshot().then((a) => {
+      if (!a) throw new Error("Snapshot unavailable");
+      if (r !== this.generation || o !== this.host.sessionId() || a.session !== null && a.session.id !== o || !s.some(n)) return;
+      const h = R(a.interaction_cursor);
+      if (h === null || k(h, this.recoveryCursor ?? e) < 0 || k(h, this._cursor) < 0) return;
+      const c = a.active_interaction === null ? null : b(a.active_interaction);
+      if (a.active_interaction !== null && (!c || !v(c))) return;
+      const l = a.messages.map(y).filter((d) => d !== null), _ = y(a.interaction_response_message);
+      c && l.push(y(c)), _?.role === "user" && l.push(_);
+      const u = s.filter((d) => n(d) && (c?.interaction_id !== d.interactionId || c.interaction_status === "accepted" && _?.role === "user")), p = new Set(u.map((d) => d.messageId));
+      this.setRows((d) => M(d.filter((I) => !p.has(I.id)), l).sort((I, it) => Date.parse(I.ts) - Date.parse(it.ts) || 0)), u.forEach((d) => this.operations.delete(d.interactionId)), this.operation && u.includes(this.operation) && (this.operation = null), this._cursor = h, this.recoveryCursor = null, this.setCursor(h), this.setActive(c), this.setSelectionPending(this.operation !== null), this.setInteractionError(null);
+    }).catch(() => {
+      r === this.generation && s.some(n) && this.setInteractionError({ code: "network", message: "Reconnecting to confirm your selection…" });
+    }).finally(() => {
+      if (r === this.generation) {
+        if (this.refreshInFlight = !1, this.operations.size === 0) {
+          this.recoveryCursor = null;
+          return;
+        }
+        const a = this.recoveryCursor;
+        a !== null && k(a, e) > 0 && this.refreshMissingOutcome(a);
+      }
+    });
+  }
+  hasMissingOutcome(t) {
+    return [...this.operations.values()].some((e) => !t || e.interactionId !== t.interaction_id);
+  }
+  applySnapshot(t) {
+    const e = R(t.interaction_cursor);
+    if (e === null || !Object.prototype.hasOwnProperty.call(t, "active_interaction")) return;
+    const s = k(e, this._cursor);
+    if (s < 0) return;
+    const n = t.active_interaction === null ? null : b(t.active_interaction);
+    if (!(t.active_interaction !== null && (!n || !v(n)))) {
+      if (s > 0 && this.hasMissingOutcome(n)) {
+        this.refreshMissingOutcome(e);
+        return;
+      }
+      s === 0 && (this.operation || n && this.operations.has(n.interaction_id) || n === null && this._active) || (this._cursor = e, this.setCursor(e), this.setActive(n), this.mergeProjection(n, t.interaction_response_message), (!n || this.operation?.interactionId !== n.interaction_id) && (this.operation = null, this.setSelectionPending(!1)));
+    }
+  }
+  applyEvent(t) {
+    if (!["interaction_published", "interaction_updated", "interaction_closed"].includes(t.type)) return !1;
+    if (t.session_id && t.session_id !== this.host.sessionId()) return !0;
+    const e = R(t.payload.interaction_cursor), s = b(t.payload);
+    return !s || s.interaction_status === "preparing" || e === null || k(e, this._cursor) <= 0 ? !0 : this.hasMissingOutcome(s) || !v(s) && this.operations.has(s.interaction_id) && !y(t.payload.interaction_response_message) ? (this.refreshMissingOutcome(e), !0) : (this._cursor = e, this.setCursor(e), this.mergeProjection(s, t.payload.interaction_response_message), v(s) ? this.setActive(s) : this._active?.interaction_id === s.interaction_id && this.setActive(null), this.operation && (this.operation.interactionId !== s.interaction_id || !v(s)) && (this.operation = null, this.setSelectionPending(!1)), !0);
+  }
+  handleWriteResult(t) {
+    const e = t, s = [...this.operations.values()].find((n) => n.messageId === e.message_id);
+    if (!s) return !1;
+    if (e.error || ["refused", "failed", "error", "busy"].includes(String(e.state))) {
+      const n = ["interaction_not_pending", "interaction_suspended", "invalid_interaction", "network"].includes(String(e.error)) ? e.error : "invalid_interaction";
+      this.reject(s, { code: n, message: String(e.error || e.reason || "The selection was not accepted. Please try again.") });
+    } else
+      s.acknowledged = !0, this.operation === s && (this.operation = null), this.setSelectionPending(!1), this.setInteractionError(null);
+    return !0;
+  }
+  respond(t, e) {
+    const s = this._active;
+    if (!this.host.sessionId() || this.host.humanConnected() || this.operation || !s || s.interaction_id !== t || s.interaction_status !== "pending" || !$.some((c) => c.tool_type === s.tool_type && c.schema_version === s.schema_version) || !et(s, e)) return !1;
+    const n = s.tool_type === "ui_buttons" && s.schema_version === 1;
+    let r = null;
+    if (n && e.kind === "selection" && Z(s.presentation))
+      r = s.presentation.options.find((c) => c.id === e.value)?.label ?? null;
+    else if (!n && e.kind === "text" && s.tool_type === "ui_buttons" && O(s.presentation))
+      r = e.value;
+    else if (!n && e.kind === "selection" && s.tool_type === "ui_buttons" && O(s.presentation))
+      r = s.presentation.options.find((c) => c.id === e.value)?.label ?? null;
+    else if (e.kind === "selection" && s.tool_type === "ui_carousel" && tt(s.presentation, void 0, !0))
+      r = s.presentation.items.find((c) => c.id === e.value)?.title ?? null;
+    else if (e.kind === "date" && s.tool_type === "ui_date_picker" && s.schema_version === 1 && L(s.presentation) && s.presentation.selection_mode === "single")
+      (!s.presentation.min_date || e.value >= s.presentation.min_date) && (!s.presentation.max_date || e.value <= s.presentation.max_date) && (r = e.value);
+    else if (e.kind === "date_range" && s.tool_type === "ui_date_picker" && s.schema_version === 1 && L(s.presentation) && s.presentation.selection_mode === "range") {
+      const { start_date: c, end_date: l } = e.value;
+      (!s.presentation.min_date || c >= s.presentation.min_date) && (!s.presentation.max_date || l <= s.presentation.max_date) && (r = `${c} to ${l}`);
+    }
+    if (!r) return !1;
+    const o = this.host.newId(), a = {
+      interactionId: t,
+      messageId: o,
+      original: s,
+      acknowledged: !1,
+      sent: !1,
+      frame: {
+        type: "interaction_response",
+        interaction_id: t,
+        ...n ? { option_id: e.value } : { response: e },
+        message_id: o,
+        idempotency_key: this.host.newId(),
+        supported_interactions: $
+      }
+    };
+    this.operations.set(t, a), this.operation = a, this.setSelectionPending(!0), this.setInteractionError(null);
+    const h = {
+      ...s,
+      interaction_status: "accepted",
+      ...n ? { selected_option_id: e.value } : { response_payload: e }
+    };
+    return this.setActive(h), this.setRows((c) => M(c, [
+      y(h),
+      { id: o, type: "message", role: "user", content: r, ts: (/* @__PURE__ */ new Date()).toISOString(), local: !0 }
+    ])), a.sent = this.host.sendFrame(a.frame), !0;
+  }
+  onConnectionOpen() {
+    const t = this.operation;
+    t && !t.acknowledged && !this.host.humanConnected() && (t.sent = this.host.sendFrame(t.frame));
+  }
+}
+function St(i) {
+  const t = [];
+  for (const e of i)
+    e.kind === "interaction" ? t.push(y(e.interaction)) : e.kind === "message" && t.push({
+      id: e.serverId ?? e.id,
+      type: "message",
+      role: e.role === "human" ? "operator" : e.role,
+      content: e.content,
+      ts: e.createdAt
+    });
+  return t;
+}
+function kt(i, t) {
+  const e = /* @__PURE__ */ new Map();
+  for (const n of t) n.kind === "message" && (e.set(n.id, n), n.serverId && e.set(n.serverId, n));
+  const s = [];
+  for (const n of i) {
+    if (n.type === "interaction" && n.interaction_id) {
+      const o = b(n);
+      o && s.push({ kind: "interaction", id: n.interaction_id, interaction: o });
+      continue;
+    }
+    if (n.role === "system") continue;
+    const r = e.get(n.id);
+    if (r) {
+      s.push(r.content === n.content ? r : { ...r, content: n.content });
+      continue;
+    }
+    if (n.local) {
+      s.push({ kind: "message", id: n.id, role: "user", content: n.content, createdAt: n.ts, status: "sending" });
+      continue;
+    }
+    s.push({
+      kind: "message",
+      id: `srv:${n.id}`,
+      serverId: n.id,
+      role: n.role === "operator" ? "human" : n.role,
+      content: n.content,
+      createdAt: n.ts,
+      status: "sent"
+    });
+  }
+  return s;
+}
+function bt(i) {
+  let t = i;
+  if (typeof i == "string")
+    try {
+      t = JSON.parse(i);
+    } catch {
+      return null;
+    }
+  if (!t || typeof t != "object" || Array.isArray(t)) return null;
+  const e = t;
+  if (typeof e.type != "string") return null;
+  const s = e.payload && typeof e.payload == "object" && !Array.isArray(e.payload) ? e.payload : {};
+  return { ...e, type: e.type, payload: s };
+}
+const It = 25e3, vt = 6e4, Tt = 3e4, z = 6e4, T = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4], x = 1e4, Ct = 4e3, At = 2, q = /* @__PURE__ */ new Set(["invalid_token", "session_not_found", "session_closed", "origin_not_allowed", "agent_archived", "agent_not_found"]);
+function st() {
+  return {
+    isVisible: () => typeof document > "u" || document.visibilityState !== "hidden",
+    onVisible: (i) => {
+      const t = () => {
+        document.visibilityState !== "hidden" && i();
+      };
+      return typeof document > "u" ? () => {
+      } : (document.addEventListener("visibilitychange", t), () => document.removeEventListener("visibilitychange", t));
+    },
+    onOnline: (i) => typeof window > "u" ? () => {
+    } : (window.addEventListener("online", i), () => window.removeEventListener("online", i))
+  };
+}
+function C(i) {
+  i && (i.onopen = null, i.onmessage = null, i.onclose = null, i.onerror = null);
+}
+class Pt {
+  constructor(t) {
+    this.opts = t, this.socket = null, this.next = null, this.stopped = !1, this.started = !1, this.everOpened = !1, this.failures = 0, this.authCloses = 0, this.epoch = 0, this.rotating = !1, this.pingSupported = !0, this.lastInbound = 0, this.lastPingSentAt = 0, this.expiresAt = 0, this.timers = /* @__PURE__ */ new Set(), this.pingTimer = null, this.waitingForPage = /* @__PURE__ */ new Set(), this.page = t.page ?? st(), this.WS = t.WebSocketImpl ?? WebSocket, this.random = t.random ?? Math.random;
+  }
+  get isOpen() {
+    return !this.stopped && this.socket?.readyState === 1;
+  }
+  start() {
+    this.started || this.stopped || (this.started = !0, this.opts.onStatus("connecting"), this.connect());
+  }
+  send(t) {
+    return this.isOpen ? (this.socket.send(JSON.stringify(t)), !0) : !1;
+  }
+  stop() {
+    this.stopped = !0, this.epoch += 1, this.clearTimers(), this.stopPings(), this.waitingForPage.forEach((t) => t()), this.waitingForPage.clear(), this.abandon(this.next), this.next = null, this.abandon(this.socket), this.socket = null;
+  }
+  abandon(t) {
+    C(t);
+    try {
+      t?.close(1e3, "client-stop");
+    } catch {
+    }
+  }
+  recoveringStatus() {
+    return this.everOpened ? "recovering" : "connecting";
+  }
+  urlFor(t) {
+    const e = t.wsUrl.includes("?") ? "&" : "?";
+    return `${t.wsUrl}${e}token=${encodeURIComponent(t.token)}&sdk=${encodeURIComponent(this.opts.sdkVersion)}`;
+  }
+  async connect() {
+    if (this.stopped) return;
+    const t = this.epoch;
+    let e;
+    try {
+      e = await this.opts.mint();
+    } catch (s) {
+      if (this.stopped || t !== this.epoch) return;
+      this.handleMintFailure(s);
+      return;
+    }
+    if (!(this.stopped || t !== this.epoch))
+      try {
+        this.openSocket(e, !1);
+      } catch (s) {
+        this.handleMintFailure(s);
+      }
+  }
+  // Handlers are bound to `s`: events from a socket that is no longer current are ignored.
+  openSocket(t, e) {
+    const s = new this.WS(this.urlFor(t));
+    e ? this.next = s : (this.socket = s, this.expiresAt = t.expiresAt), s.onopen = () => {
+      this.stopped || (e ? this.next === s && this.swapIn(s, t.expiresAt) : this.socket === s && this.handleOpen());
+    }, s.onmessage = (n) => {
+      this.socket === s && this.handleMessage(n.data);
+    }, s.onclose = (n) => {
+      if (!this.stopped) {
+        if (this.next === s) {
+          C(s), this.next = null, this.later(x, () => this.whenVisible(() => {
+            this.rotate();
+          }));
+          return;
+        }
+        this.socket === s && this.handleClose(n.code, n.reason);
+      }
+    };
+  }
+  handleOpen() {
+    const t = this.everOpened;
+    this.everOpened = !0, this.failures = 0, this.authCloses = 0, this.pingSupported = !0, this.lastInbound = Date.now(), this.opts.onStatus("open"), !this.stopped && (this.startPings(), this.scheduleRotation(), !this.stopped && (this.opts.onOpen(), t && !this.stopped && this.opts.onReconnected()));
+  }
+  swapIn(t, e) {
+    const s = this.socket;
+    this.next = null, this.socket = t, this.expiresAt = e, this.failures = 0, this.authCloses = 0, this.pingSupported = !0, C(s);
+    try {
+      s?.close(Ct, "token-refresh");
+    } catch {
+    }
+    this.clearTimers(), this.lastInbound = Date.now(), this.startPings(), this.scheduleRotation(), this.opts.onOpen(), this.stopped || this.opts.onReconnected();
+  }
+  handleMessage(t) {
+    if (this.stopped) return;
+    this.lastInbound = Date.now();
+    const e = bt(t);
+    if (e) {
+      if (e.type === "ws_write_result" && e.payload.error === "invalid_input_type" && !e.payload.message_id) {
+        this.pingSupported = !1, this.stopPings();
+        return;
+      }
+      this.opts.onFrame(e);
+    }
+  }
+  handleClose(t, e) {
+    if (!this.stopped) {
+      if (this.epoch += 1, C(this.socket), this.socket = null, this.abandon(this.next), this.next = null, this.rotating = !1, this.stopPings(), this.clearTimers(), this.clearPageListeners(), t === 4401) {
+        if (this.authCloses += 1, this.authCloses > At) {
+          this.opts.onError(f("invalid_token")), this.scheduleBackoff();
+          return;
+        }
+        this.opts.onStatus(this.recoveringStatus()), this.whenVisible(() => this.reconnectNow());
+        return;
+      }
+      if (t === 1008 && e === "agent_inactive") {
+        this.opts.onError(f("agent_inactive")), this.stopped || this.opts.onStatus(this.recoveringStatus()), this.later(z, () => this.reconnectNow());
+        return;
+      }
+      if (t === 1008) {
+        this.terminate(e || "policy");
+        return;
+      }
+      this.scheduleBackoff();
+    }
+  }
+  handleMintFailure(t) {
+    const e = t instanceof m ? t.error : f("network");
+    if (e.code === "agent_inactive") {
+      this.opts.onError(e), this.stopped || this.opts.onStatus(this.recoveringStatus()), this.later(z, () => this.reconnectNow());
+      return;
+    }
+    if (q.has(e.code)) {
+      this.terminate(e.code);
+      return;
+    }
+    if (e.code === "rate_limited" && e.retryAfterSeconds) {
+      this.opts.onError(e), this.stopped || this.opts.onStatus(this.recoveringStatus()), this.later(e.retryAfterSeconds * 1e3, () => this.reconnectNow());
+      return;
+    }
+    this.scheduleBackoff();
+  }
+  reconnectNow() {
+    this.stopped || (this.opts.onStatus(this.recoveringStatus()), this.connect());
+  }
+  scheduleBackoff() {
+    if (this.stopped) return;
+    const t = Math.min(this.failures, T.length - 1);
+    if (this.failures += 1, this.failures > T.length) {
+      this.opts.onStatus("offline"), this.retryWhenReachable();
+      return;
+    }
+    this.opts.onStatus(this.recoveringStatus());
+    const e = Math.round(T[t] * (0.8 + 0.4 * this.random()));
+    this.later(e, () => {
+      this.connect();
+    });
+  }
+  // First of online / visible / 30 s timer wins and cancels the other two.
+  retryWhenReachable() {
+    if (this.stopped) return;
+    let t = !1;
+    const e = () => {
+      clearTimeout(o), this.timers.delete(o), n(), r(), this.waitingForPage.delete(e);
+    }, s = () => {
+      t || this.stopped || (t = !0, e(), this.reconnectNow());
+    }, n = this.page.onVisible(s), r = this.page.onOnline(s), o = setTimeout(() => {
+      this.stopped || s();
+    }, T[T.length - 1]);
+    this.timers.add(o), this.waitingForPage.add(e);
+  }
+  whenVisible(t) {
+    if (this.stopped) return;
+    if (this.page.isVisible()) {
+      t();
+      return;
+    }
+    let e = !1;
+    const s = this.page.onVisible(() => {
+      e || this.stopped || !this.page.isVisible() || (e = !0, s(), this.waitingForPage.delete(s), t());
+    });
+    this.waitingForPage.add(s);
+  }
+  startPings() {
+    this.stopPings(), this.lastPingSentAt = 0, this.pingTimer = setInterval(() => {
+      if (this.stopped || !this.isOpen || !this.pingSupported) return;
+      const t = Date.now(), e = this.lastPingSentAt > this.lastInbound;
+      if (this.page.isVisible() && e && t - this.lastInbound >= vt) {
+        this.declareDead();
+        return;
+      }
+      this.send({ type: "ping" }) && (this.lastPingSentAt = t);
+    }, It);
+  }
+  declareDead() {
+    const t = this.socket;
+    if (t) {
+      C(t);
+      try {
+        t.close(4001, "silent");
+      } catch {
+      }
+      this.handleClose(4001, "silent");
+    }
+  }
+  stopPings() {
+    this.pingTimer !== null && clearInterval(this.pingTimer), this.pingTimer = null;
+  }
+  scheduleRotation() {
+    const t = Math.max(5e3, this.expiresAt - Date.now() - Tt);
+    this.later(t, () => this.whenVisible(() => {
+      this.rotate();
+    }));
+  }
+  // Mint first, open the new socket, close the old one only once the new one is open.
+  async rotate() {
+    if (this.stopped || this.rotating || !this.isOpen || this.next) return;
+    this.rotating = !0;
+    const t = this.epoch;
+    let e;
+    try {
+      e = await this.opts.mint();
+    } catch (s) {
+      if (this.stopped || t !== this.epoch) return;
+      this.rotating = !1;
+      const n = s instanceof m ? s.error : f("network");
+      if (q.has(n.code)) {
+        this.terminate(n.code);
+        return;
+      }
+      const r = n.retryAfterSeconds ? n.retryAfterSeconds * 1e3 : x;
+      this.later(r, () => this.whenVisible(() => {
+        this.rotate();
+      }));
+      return;
+    }
+    if (!(this.stopped || t !== this.epoch)) {
+      this.rotating = !1;
+      try {
+        this.openSocket(e, !0);
+      } catch {
+        this.later(x, () => this.whenVisible(() => {
+          this.rotate();
+        }));
+      }
+    }
+  }
+  terminate(t) {
+    this.stop(), this.opts.onClosed(t);
+  }
+  later(t, e) {
+    if (this.stopped) return;
+    const s = setTimeout(() => {
+      this.timers.delete(s), this.stopped || e();
+    }, t);
+    this.timers.add(s);
+  }
+  clearPageListeners() {
+    this.waitingForPage.forEach((t) => t()), this.waitingForPage.clear();
+  }
+  clearTimers() {
+    this.timers.forEach(clearTimeout), this.timers.clear();
+  }
+}
+const U = "osvi.chat.visitor", Et = /^web:[0-9a-f]{32}$/;
+function Ot() {
+  const i = /* @__PURE__ */ new Map();
+  return {
+    get: (t) => i.get(t) ?? null,
+    set: (t, e) => {
+      i.set(t, e);
+    },
+    remove: (t) => {
+      i.delete(t);
+    }
+  };
+}
+function Rt() {
+  const i = Ot();
+  let t = !1;
+  const e = (s, n) => {
+    if (t) return n();
+    try {
+      return s();
+    } catch {
+      return t = !0, n();
+    }
+  };
+  return {
+    get: (s) => e(() => window.localStorage.getItem(s), () => i.get(s)),
+    set: (s, n) => e(() => window.localStorage.setItem(s, n), () => i.set(s, n)),
+    remove: (s) => e(() => window.localStorage.removeItem(s), () => i.remove(s))
+  };
+}
+const Y = (i) => `web:${Array.from(i, (t) => t.toString(16).padStart(2, "0")).join("")}`;
+let F = null;
+function A(i, t) {
+  const e = i.get(U);
+  if (e && Et.test(e)) return e;
+  e !== null && i.remove(U);
+  let s;
+  try {
+    s = globalThis.crypto?.getRandomValues?.(new Uint8Array(16));
+  } catch {
+  }
+  if (s) {
+    const n = Y(s);
+    return i.set(U, n), n;
+  }
+  if (!F) {
+    const n = new Uint8Array(16);
+    for (let r = 0; r < n.length; r += 1)
+      n[r] = Math.floor(Math.random() * 256);
+    F = Y(n);
+  }
+  return F;
+}
+function D(i) {
+  return `osvi.chat.session.${i}`;
+}
+const Mt = "https://api.osvi.ai", Nt = 12e4, xt = 15e3, K = [1e3, 2e3, 4e3, 8e3, 16e3], Ut = 2048, Ft = /* @__PURE__ */ new Set(["session_closed", "session_dormant", "new_session"]);
+function E() {
+  const i = globalThis.crypto;
+  if (i?.randomUUID) return i.randomUUID();
+  if (i?.getRandomValues) {
+    const t = i.getRandomValues(new Uint8Array(16));
+    t[6] = t[6] & 15 | 64, t[8] = t[8] & 63 | 128;
+    const e = Array.from(t, (s) => s.toString(16).padStart(2, "0")).join("");
+    return `${e.slice(0, 8)}-${e.slice(8, 12)}-${e.slice(12, 16)}-${e.slice(16, 20)}-${e.slice(20)}`;
+  }
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+}
+const H = () => ({
+  status: "idle",
+  mode: "ai",
+  awaitingReply: !1,
+  items: [],
+  activeInteraction: null,
+  interactionPending: !1,
+  agent: null,
+  error: null
+}), J = {
+  user: "user",
+  ai: "assistant",
+  assistant: "assistant",
+  operator: "human",
+  support: "human"
+};
+class Dt {
+  // server mode: rotation returned a different session
+  constructor(t) {
+    this.opts = t, this.state = H(), this.listeners = /* @__PURE__ */ new Set(), this.conn = null, this.sessionId = null, this.latestToken = null, this.chain = Promise.resolve(), this.startP = null, this.ensureP = null, this.pending = /* @__PURE__ */ new Map(), this.openGen = 0, this.sessionGeneration = 0, this.seen = [], this.seenSet = /* @__PURE__ */ new Set(), this.timers = /* @__PURE__ */ new Set(), this.awaitingTimer = null, this.destroyed = !1, this.wantNewServerSession = !1, this.switchTo = null, this.http = new ct(t.baseUrl ?? Mt, t.fetch), this.store = t.store ?? Rt(), this.page = t.page ?? st(), this.interactions = new wt({
+      sessionId: () => this.sessionId,
+      humanConnected: () => this.state.mode === "human",
+      sendFrame: (e) => this.conn?.send(e) ?? !1,
+      updateItems: (e) => this.patch({ items: e(this.state.items) }),
+      refreshSnapshot: () => this.fetchSnapshot(),
+      onChange: () => this.patch({}),
+      newId: E
+    });
+  }
+  get serverMode() {
+    return this.opts.auth?.mode === "server";
+  }
+  serialize(t) {
+    const e = this.chain.then(t);
+    return this.chain = e.catch(() => {
+    }), e;
+  }
+  // ---------- public API ----------
+  start() {
+    return this.destroyed ? Promise.resolve() : (this.startP || (this.startP = this.serialize(() => this.doStart()).finally(() => {
+      this.startP = null;
+    })), this.startP);
+  }
+  async doStart() {
+    if (!(this.destroyed || this.sessionId && this.conn)) {
+      if (this.serverMode) {
+        await this.openServerSession();
+        return;
+      }
+      try {
+        const t = await this.http.bootstrap(this.opts.agentId, A(this.store));
+        if (this.destroyed) return;
+        this.patch({ agent: { agentId: this.opts.agentId, name: t.agent?.name ?? "" } }), t.session?.id && t.session.status === "active" ? this.adopt(t.session.id, t, this.pending.size ? "append" : "replace") : this.store.remove(D(this.opts.agentId));
+      } catch (t) {
+        this.fail(t, !1);
+      }
+    }
+  }
+  async send(t) {
+    if (this.destroyed) return { ok: !1, reason: "destroyed" };
+    const e = t.trim();
+    if (!e) return { ok: !1, reason: "empty" };
+    if (this.state.mode === "ai" && (this.interactions.pending || this.interactions.active?.interaction_status === "pending"))
+      return { ok: !1, reason: "awaiting_interaction" };
+    const s = E(), n = E(), r = {
+      kind: "message",
+      id: s,
+      role: "user",
+      content: e,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "sending",
+      idempotencyKey: n
+    };
+    return this.patch({ items: [...this.state.items, r] }), this.pending.set(s, { frame: this.frameFor(r), attempts: 0, gen: -1, ackTimer: null }), await this.ensureSession() ? (this.transmit(s), { ok: !0, messageId: s }) : (this.dropPending(s), this.setMessage(s, { status: "failed" }), { ok: !1, reason: "unavailable" });
+  }
+  async respond(t, e) {
+    return this.destroyed ? !1 : this.interactions.respond(t, e);
+  }
+  async retry(t) {
+    const e = this.state.items.find((s) => s.kind === "message" && s.id === t);
+    return !e || e.status !== "failed" || !e.idempotencyKey || this.destroyed ? !1 : (this.dropPending(t), this.pending.set(t, { frame: this.frameFor(e), attempts: 0, gen: -1, ackTimer: null }), this.setMessage(t, { status: "sending" }), await this.ensureSession() ? (this.transmit(t), !0) : (this.dropPending(t), this.setMessage(t, { status: "failed" }), !1));
+  }
+  newSession() {
+    return this.destroyed ? Promise.resolve(!1) : !this.sessionId && this.ensureP ? this.ensureP.then((t) => t !== null) : this.serialize(async () => {
+      if (this.destroyed) return !1;
+      if (this.sessionId && this.endSession("new_session"), this.serverMode)
+        return this.wantNewServerSession = !0, await this.openServerSession() !== null;
+      try {
+        const t = await this.http.createSession(this.opts.agentId, A(this.store));
+        return this.destroyed ? !1 : (this.adopt(t.id, null, "keep"), !0);
+      } catch (t) {
+        return this.fail(t, !1), !1;
+      }
+    });
+  }
+  subscribe(t) {
+    return this.listeners.add(t), () => this.listeners.delete(t);
+  }
+  getState() {
+    return this.state;
+  }
+  resolveUrl(t) {
+    return this.http.resolveUrl(t);
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.sessionGeneration += 1, this.conn?.stop(), this.conn = null, this.timers.forEach(clearTimeout), this.timers.clear(), this.pending.forEach((t) => {
+      t.ackTimer && clearTimeout(t.ackTimer);
+    }), this.pending.clear(), this.awaitingTimer && clearTimeout(this.awaitingTimer), this.interactions.reset(), this.sessionId = null, this.latestToken = null, this.switchTo = null, this.state = H(), this.listeners.clear());
+  }
+  // ---------- sessions ----------
+  ensureSession() {
+    return this.ensureP ? this.ensureP : (this.ensureP = this.serialize(async () => this.destroyed ? null : this.sessionId ? this.sessionId : this.serverMode ? this.openServerSession() : this.openAnonymousSession()).finally(() => {
+      this.ensureP = null;
+    }), this.ensureP);
+  }
+  async openAnonymousSession() {
+    try {
+      const t = A(this.store), e = await this.http.bootstrap(this.opts.agentId, t);
+      if (this.destroyed) return null;
+      if (this.patch({ agent: { agentId: this.opts.agentId, name: e.agent?.name ?? "" } }), e.session?.id && e.session.status === "active")
+        return this.adopt(e.session.id, e, "append"), this.sessionId;
+      const s = await this.http.createSession(this.opts.agentId, t);
+      return this.destroyed ? null : (this.adopt(s.id, null, "keep"), this.sessionId);
+    } catch (t) {
+      return this.fail(t, !1), null;
+    }
+  }
+  async openServerSession(t) {
+    const e = this.sessionGeneration;
+    try {
+      let s = t ? this.accept(t) : await this.serverToken(e);
+      this.assertCurrent(e), this.latestToken = s.token;
+      let n;
+      try {
+        n = await this.http.snapshot(s.sessionId, s.token);
+      } catch (r) {
+        if (this.assertCurrent(e), !(r instanceof m) || r.error.code !== "invalid_token") throw r;
+        s = await this.serverToken(e), this.assertCurrent(e), this.latestToken = s.token, n = await this.http.snapshot(s.sessionId, s.token);
+      }
+      return this.assertCurrent(e), this.adopt(s.sessionId, n, this.state.items.length ? "append" : "replace", s), this.sessionId;
+    } catch (s) {
+      return this.isCurrent(e) && this.fail(s, !0), null;
+    }
+  }
+  async serverToken(t = this.sessionGeneration) {
+    if (this.assertCurrent(t), this.opts.auth?.mode !== "server") throw new Error("not server mode");
+    let e;
+    const s = this.wantNewServerSession;
+    this.wantNewServerSession = !1;
+    try {
+      e = await (s ? this.opts.auth.getToken({ newSession: !0 }) : this.opts.auth.getToken());
+    } catch {
+      throw new m(f("token_failed", "getToken failed"), 0);
+    }
+    this.assertCurrent(t);
+    try {
+      return this.accept(e);
+    } catch (n) {
+      throw this.isCurrent(t) && this.fail(n, !1), n;
+    }
+  }
+  accept(t) {
+    return this.checkWsUrl(t.wsUrl), { ...t, expiresAt: X(t.expiresAt) };
+  }
+  // wss: only (ws: for localhost during development); anything else is a token failure.
+  checkWsUrl(t) {
+    let e = null;
+    try {
+      e = new URL(t);
+    } catch {
+    }
+    const s = e?.hostname === "localhost" || e?.hostname === "127.0.0.1";
+    if (e && (e.protocol === "wss:" || e.protocol === "ws:" && s)) return;
+    const n = f("token_failed", "The chat stream URL must use wss://");
+    throw new m(n, 0);
+  }
+  isCurrent(t, e) {
+    return !this.destroyed && this.sessionGeneration === t && (e === void 0 || this.sessionId === e);
+  }
+  assertCurrent(t, e) {
+    if (!this.isCurrent(t, e)) throw new m(f("session_closed"), 0);
+  }
+  /** Bind to a session; `firstToken` lets server mode reuse the token it just fetched. */
+  adopt(t, e, s, n, r = !0) {
+    if (this.sessionId === t && this.conn) return;
+    this.conn?.stop(), this.conn = null, this.sessionId = t;
+    const o = ++this.sessionGeneration;
+    this.serverMode || this.store.set(D(this.opts.agentId), t), e && this.applySnapshot(e, s);
+    let a = n ?? null;
+    const h = this.serverMode ? null : A(this.store);
+    let c = !0, l = !1;
+    const _ = async () => {
+      if (this.assertCurrent(o, t), a) {
+        const d = a;
+        return a = null, this.latestToken = d.token, d;
+      }
+      if (this.serverMode) {
+        const d = await this.serverToken(o);
+        if (this.assertCurrent(o, t), d.sessionId !== t)
+          throw this.switchTo = d, new m(f("session_closed"), 0);
+        return this.latestToken = d.token, d;
+      }
+      const u = c;
+      c = !1;
+      let p;
+      try {
+        p = await this.http.mintPublicToken(t);
+      } catch (d) {
+        throw l = u && r && this.isCurrent(o, t) && d instanceof m && d.status === 404 && d.error.code === "session_not_found" && [...this.pending.values()].every((I) => I.gen === -1), d;
+      }
+      this.assertCurrent(o, t);
+      try {
+        this.checkWsUrl(p.wsUrl);
+      } catch (d) {
+        throw this.fail(d, !1), d;
+      }
+      return this.latestToken = p.token, p;
+    };
+    this.conn = new Pt({
+      mint: _,
+      sdkVersion: nt,
+      page: this.page,
+      random: this.opts.random,
+      WebSocketImpl: this.opts.WebSocketImpl,
+      onFrame: (u) => this.onFrame(u),
+      onStatus: (u) => this.patch({ status: u, ...u === "open" ? { error: null } : {} }),
+      onOpen: () => this.onOpen(),
+      onReconnected: () => {
+        this.recover();
+      },
+      onError: (u) => this.patch({ error: u }),
+      onClosed: (u) => {
+        if (!this.isCurrent(o, t)) return;
+        if (l && h && u === "session_not_found") {
+          l = !1, this.serialize(() => this.replaceBeforeFirstWrite(o, t, h));
+          return;
+        }
+        const p = this.switchTo;
+        this.switchTo = null, this.endSession(u), p && this.serialize(() => this.openServerSession(p));
+      }
+    }), this.conn.start();
+  }
+  /** An initial mint can lose to a sibling tab before this tab has written anything. */
+  async replaceBeforeFirstWrite(t, e, s) {
+    if (this.isCurrent(t, e))
+      try {
+        const n = await this.http.bootstrap(this.opts.agentId, s);
+        if (!this.isCurrent(t, e)) return;
+        const r = n?.session, o = r, a = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+        if (n?.agent?.agent_uuid !== this.opts.agentId || !Array.isArray(n.messages) || !r || typeof r.id != "string" || !a.test(r.id) || r.id === e || r.status !== "active" || r.mode !== "ai" && r.mode !== "support" || o && "customer_id" in o && o.customer_id !== s || o && "agent_uuid" in o && o.agent_uuid !== this.opts.agentId || [...this.pending.values()].some((h) => h.gen !== -1)) {
+          this.endSession("session_not_found");
+          return;
+        }
+        this.adopt(r.id, n, "append", void 0, !1);
+      } catch {
+        this.isCurrent(t, e) && this.endSession("session_not_found");
+      }
+  }
+  // Every socket that becomes current (first open, reconnect, rotation): resend what is unacked.
+  onOpen() {
+    this.openGen += 1, this.seen = [], this.seenSet.clear();
+    for (const t of [...this.pending.keys()]) this.write(t);
+    this.interactions.onConnectionOpen();
+  }
+  async recover() {
+    const t = this.sessionId, e = this.sessionGeneration, s = await this.fetchSnapshot();
+    s && t && this.isCurrent(e, t) && this.applySnapshot(s, "reconcile");
+  }
+  async fetchSnapshot() {
+    if (this.destroyed) return null;
+    const t = this.sessionId, e = this.sessionGeneration;
+    if (!t) return null;
+    try {
+      try {
+        const s = await this.http.snapshot(t, this.latestToken ?? await this.mintFresh(t));
+        return this.isCurrent(e, t) ? s : null;
+      } catch (s) {
+        if (this.assertCurrent(e, t), !(s instanceof m) || s.error.code !== "invalid_token") throw s;
+        const n = await this.http.snapshot(t, await this.mintFresh(t));
+        return this.isCurrent(e, t) ? n : null;
+      }
+    } catch (s) {
+      if (s instanceof m && s.error.code === "session_not_found") {
+        if (!this.isCurrent(e, t)) return null;
+        this.endSession("session_closed"), this.serverMode || this.readoptAfterReplacement();
+      }
+      return null;
+    }
+  }
+  async mintFresh(t) {
+    const e = this.sessionGeneration;
+    if (this.assertCurrent(e, t), this.serverMode) {
+      const n = await this.serverToken(e);
+      return this.assertCurrent(e, t), this.latestToken = n.token, n.token;
+    }
+    const s = await this.http.mintPublicToken(t);
+    return this.assertCurrent(e, t), this.checkWsUrl(s.wsUrl), this.latestToken = s.token, s.token;
+  }
+  async readoptAfterReplacement() {
+    try {
+      const t = await this.http.bootstrap(this.opts.agentId, A(this.store));
+      !this.destroyed && !this.sessionId && t.session?.id && t.session.status === "active" && this.adopt(t.session.id, t, "append");
+    } catch {
+    }
+  }
+  endSession(t) {
+    if (this.destroyed) return;
+    this.sessionGeneration += 1, this.conn?.stop(), this.conn = null, this.sessionId = null, this.latestToken = null, this.serverMode || this.store.remove(D(this.opts.agentId)), this.interactions.reset(), this.pending.forEach((r) => {
+      r.ackTimer && clearTimeout(r.ackTimer);
+    }), this.pending.clear();
+    const e = this.state.items.map((r) => r.kind === "message" && r.status === "sending" ? { ...r, status: "failed" } : r), s = e[e.length - 1], n = { kind: "divider", id: E(), reason: "session_ended" };
+    this.setAwaiting(!1), this.patch({
+      status: "closed",
+      mode: "ai",
+      items: e.length && s?.kind !== "divider" ? [...e, n] : e,
+      ...Ft.has(t) ? {} : { error: f(t) }
+    });
+  }
+  // ---------- frames ----------
+  onFrame(t) {
+    if (this.destroyed) return;
+    if (t.event_id !== void 0) {
+      const s = String(t.event_id);
+      if (this.seenSet.has(s)) return;
+      this.seenSet.add(s), this.seen.push(s), this.seen.length > Ut && this.seenSet.delete(this.seen.shift());
+    }
+    const e = t.payload;
+    switch (t.type) {
+      case "ws_write_result":
+        this.interactions.handleWriteResult(e) || this.onWriteResult(e);
+        return;
+      case "message_received": {
+        if (e.type === "interaction") return;
+        const s = N(e);
+        if (!s) return;
+        s.role === "user" ? this.onUserEcho(s.id, s.content, s.created_at, typeof e.message_id == "string" ? e.message_id : void 0) : this.appendRemote(s.id, s.role, s.content, s.created_at);
+        return;
+      }
+      case "operator_message": {
+        const s = N({ ...e, role: "operator" });
+        s && this.appendRemote(s.id, "operator", s.content, s.created_at);
+        return;
+      }
+      case "mode_changed":
+        e.to === "support" ? this.setMode("human") : e.to === "ai" && this.setMode("ai");
+        return;
+      case "takeover_started":
+        this.setMode("human");
+        return;
+      case "takeover_ended":
+        this.setMode("ai");
+        return;
+      case "interaction_published":
+      case "interaction_updated":
+      case "interaction_closed":
+        this.interactions.applyEvent(t) && t.type === "interaction_published" && this.setAwaiting(!1), this.patch({});
+        return;
+      case "turn_result":
+        (e.state === "failed" || e.state === "error") && (this.setAwaiting(!1), this.patch({ error: { code: "unknown", message: "The assistant could not reply", retryable: !0 } }));
+        return;
+      case "session_closed":
+      case "session_dormant":
+        this.endSession(t.type);
+        return;
+      default:
+        return;
+    }
+  }
+  onWriteResult(t) {
+    const e = t.message_id;
+    if (!e) return;
+    const s = this.pending.get(e);
+    if (s) {
+      if (s.ackTimer && (clearTimeout(s.ackTimer), s.ackTimer = null), t.state === "accepted" || t.state === "merged" || t.state === "done") {
+        this.pending.delete(e), this.setMessage(e, { status: "sent" }), this.setAwaiting(!0);
+        return;
+      }
+      if (t.state === "busy" && s.attempts < K.length) {
+        const n = K[s.attempts];
+        s.attempts += 1, this.later(n, () => {
+          this.pending.get(e) === s && (s.gen = -1, this.transmit(e));
+        });
+        return;
+      }
+      this.pending.delete(e), this.setMessage(e, { status: "failed" }), this.patch({ error: f(t.error, t.error) });
+    }
+  }
+  /** Our own message comes back as a user echo: adopt it (by client message_id, else by content on an older engine). */
+  onUserEcho(t, e, s, n) {
+    const r = this.state.items;
+    if (r.some((a) => a.kind === "message" && a.serverId === t)) return;
+    const o = n ? r.findIndex((a) => a.kind === "message" && a.role === "user" && a.id === n) : r.findIndex((a) => a.kind === "message" && a.role === "user" && !a.serverId && a.status !== "failed" && a.content === e);
+    if (o >= 0) {
+      const a = r.slice(), h = a[o];
+      a[o] = { ...h, serverId: t, status: "sent" }, this.dropPending(h.id), this.patch({ items: a });
+      return;
+    }
+    this.appendRemote(t, "user", e, s);
+  }
+  appendRemote(t, e, s, n) {
+    const r = J[e];
+    if (!r || this.state.items.some((a) => a.kind === "message" && a.serverId === t)) return;
+    const o = {
+      kind: "message",
+      id: `srv:${t}`,
+      serverId: t,
+      role: r,
+      content: s,
+      createdAt: n ?? (/* @__PURE__ */ new Date()).toISOString(),
+      status: "sent"
+    };
+    this.patch({ items: [...this.state.items, o] }), r !== "user" && this.setAwaiting(!1);
+  }
+  // ---------- snapshot → items ----------
+  applySnapshot(t, e) {
+    if (this.destroyed) return;
+    const s = [], n = /* @__PURE__ */ new Map();
+    for (const h of t.messages ?? []) {
+      const c = b(h);
+      if (c) {
+        s.push({ kind: "interaction", id: c.interaction_id, interaction: c });
+        continue;
+      }
+      const l = N(h), _ = l ? J[l.role] : void 0;
+      if (l && _) {
+        s.push({
+          kind: "message",
+          id: `srv:${l.id}`,
+          serverId: l.id,
+          role: _,
+          content: l.content,
+          createdAt: l.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+          status: "sent"
+        });
+        const u = h.message_id;
+        typeof u == "string" && n.set(l.id, u);
+      }
+    }
+    let r = this.state.items;
+    if (e === "replace") r = s;
+    else if (e === "append") {
+      let h = r.length;
+      for (; h > 0; ) {
+        const c = r[h - 1];
+        if (c.kind === "message" && c.role === "user" && c.status === "sending" && !c.serverId) h -= 1;
+        else break;
+      }
+      r = [...r.slice(0, h), ...s, ...r.slice(h)];
+    } else if (e === "reconcile") {
+      const h = new Set(r.flatMap((c) => c.kind === "message" ? [c.serverId] : c.kind === "interaction" ? [c.id] : []));
+      for (const c of s) {
+        const l = c.kind === "message" ? c.serverId : c.id;
+        if (c.kind === "message" && c.role === "user" && !h.has(l)) {
+          const _ = n.get(c.serverId), u = r.findIndex((p) => p.kind === "message" && p.role === "user" && !p.serverId && (_ ? p.id === _ : p.content === c.content));
+          if (u >= 0) {
+            const p = r[u];
+            r = r.slice(), r[u] = { ...p, serverId: c.serverId, status: "sent" }, this.dropPending(p.id), h.add(l);
+            continue;
+          }
+        }
+        h.has(l) || (r = [...r, c], h.add(l));
+      }
+    }
+    const o = t.session;
+    this.patch({ items: r, ...o ? { mode: o.mode === "support" ? "human" : "ai" } : {} }), this.interactions.applySnapshot(t);
+    const a = r.filter((h) => h.kind !== "divider").at(-1);
+    a && !(a.kind === "message" && a.role === "user") && this.setAwaiting(!1), this.patch({});
+  }
+  // ---------- sends ----------
+  frameFor(t) {
+    return {
+      type: "message",
+      content: t.content,
+      message_id: t.id,
+      idempotency_key: t.idempotencyKey,
+      supported_interactions: $
+    };
+  }
+  transmit(t) {
+    this.write(t);
+  }
+  // Write once per socket generation; an ack timer starts with every write.
+  write(t) {
+    const e = this.pending.get(t);
+    !e || !this.conn?.isOpen || e.gen === this.openGen || this.conn.send(e.frame) && (e.gen = this.openGen, e.ackTimer && clearTimeout(e.ackTimer), e.ackTimer = setTimeout(() => {
+      this.onAckTimeout(t);
+    }, xt));
+  }
+  // No ack within 15 s: reconcile with the server; if the message is still unconfirmed, it failed (retry reuses the key).
+  async onAckTimeout(t) {
+    const e = this.pending.get(t);
+    if (!e || this.destroyed || (e.ackTimer = null, !this.conn?.isOpen)) return;
+    const s = this.openGen;
+    await this.recover(), !(this.destroyed || this.pending.get(t) !== e || !this.conn?.isOpen || s !== this.openGen) && (this.dropPending(t), this.setMessage(t, { status: "failed" }), this.patch({ error: f("network", "The message could not be confirmed") }));
+  }
+  dropPending(t) {
+    const e = this.pending.get(t);
+    e?.ackTimer && clearTimeout(e.ackTimer), this.pending.delete(t);
+  }
+  // ---------- helpers ----------
+  setMode(t) {
+    this.setAwaiting(!1), this.patch({ mode: t });
+  }
+  setAwaiting(t) {
+    this.awaitingTimer && (clearTimeout(this.awaitingTimer), this.awaitingTimer = null), t && (this.awaitingTimer = setTimeout(() => {
+      this.awaitingTimer = null, this.patch({ awaitingReply: !1 });
+    }, Nt)), this.state.awaitingReply !== t && this.patch({ awaitingReply: t });
+  }
+  setMessage(t, e) {
+    this.patch({ items: this.state.items.map((s) => s.kind === "message" && s.id === t ? { ...s, ...e } : s) });
+  }
+  fail(t, e) {
+    const s = t instanceof m ? t.error : f("network", "Network error");
+    this.patch({ error: s, ...e || !s.retryable ? { status: "closed" } : {} });
+  }
+  later(t, e) {
+    const s = setTimeout(() => {
+      this.timers.delete(s), this.destroyed || e();
+    }, t);
+    this.timers.add(s);
+  }
+  patch(t) {
+    if (this.destroyed) return;
+    const e = {
+      ...this.state,
+      ...t,
+      activeInteraction: this.interactions.active,
+      interactionPending: this.interactions.pending
+    };
+    Object.keys(e).some((n) => e[n] !== this.state[n]) && (this.state = e, this.listeners.forEach((n) => n(e)));
+  }
+}
+function Vt(i) {
+  return new Dt(i);
+}
+export {
+  Nt as A,
+  Mt as D,
+  nt as S,
+  gt as a,
+  P as b,
+  Vt as c,
+  xt as d,
+  $ as e,
+  $t as i
+};
+//# sourceMappingURL=index-BsRyQwUM.js.map