@opencx/widget 2.6.1 → 2.6.3

package/dist/api-CAm3rFZk.js

@@ -0,0 +1,1070 @@
+var j = Object.defineProperty;
+var q = (t) => {
+  throw TypeError(t);
+};
+var z = (t, e, s) => e in t ? j(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var f = (t, e, s) => z(t, typeof e != "symbol" ? e + "" : e, s), B = (t, e, s) => e.has(t) || q("Cannot " + s);
+var p = (t, e, s) => (B(t, e, "read from private field"), s ? s.call(t) : e.get(t)), F = (t, e, s) => e.has(t) ? q("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, s), I = (t, e, s, r) => (B(t, e, "write to private field"), r ? r.call(t, s) : e.set(t, s), s);
+import X from "lodash.isequal";
+import { v4 as J } from "uuid";
+import K from "openapi-fetch";
+import V from "axios";
+class _ extends Error {
+  constructor(e) {
+    super(e), this.name = "OpenCXError";
+  }
+}
+class pe extends _ {
+  constructor(e = "Connection failed") {
+    super(e), this.name = "ConnectionError";
+  }
+}
+class Ee extends _ {
+  constructor(e = "Authentication failed") {
+    super(e), this.name = "AuthenticationError";
+  }
+}
+class Y extends _ {
+  constructor(e = "Session error occurred") {
+    super(e), this.name = "SessionError";
+  }
+}
+class he extends Y {
+  constructor(e = "Session not defined") {
+    super(e), this.name = "SessionNotDefinedError";
+  }
+}
+class be extends _ {
+  constructor(e = "Transport error occurred") {
+    super(e), this.name = "TransportError";
+  }
+}
+class Pe extends _ {
+  constructor(e = "File upload failed") {
+    super(e), this.name = "FileUploadError";
+  }
+}
+class Q extends _ {
+  constructor(e = "Storage is not available") {
+    super(e), this.name = "StorageNotAvailableError";
+  }
+}
+class ye extends _ {
+  constructor(e = "External ID is not defined") {
+    super(e), this.name = "ExternalIdNotDefinedError";
+  }
+}
+var W = /* @__PURE__ */ ((t) => (t.INIT = "init", t.STATE_CHANGE = "stateChange", t.BEFORE_UPDATE = "beforeUpdate", t.AFTER_UPDATE = "afterUpdate", t.DESTROY = "destroy", t.ERROR = "error", t))(W || {}), A, M;
+class R {
+  constructor(e) {
+    f(this, "subscribers", /* @__PURE__ */ new Set());
+    F(this, A);
+    f(this, "initialState");
+    F(this, M);
+    f(this, "lifecycleListeners", /* @__PURE__ */ new Map());
+    f(this, "emitLifecycle", (e, s) => {
+      const r = this.lifecycleListeners.get(e);
+      if (r) {
+        const u = {
+          type: e,
+          timestamp: Date.now(),
+          data: s
+        };
+        r.forEach((d) => {
+          try {
+            d(u);
+          } catch {
+          }
+        });
+      }
+    });
+    f(this, "notifySubscribers", (e) => {
+      Array.from(this.subscribers).forEach((r) => {
+        try {
+          r(e);
+        } catch (u) {
+          this.emitLifecycle("error", { error: u });
+        }
+      });
+    });
+    /**
+     * Subscribe to state changes
+     * @param callback Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    f(this, "subscribe", (e) => (this.subscribers.add(e), () => {
+      this.subscribers.delete(e);
+    }));
+    f(this, "onLifecycle", (e, s) => {
+      this.lifecycleListeners.has(e) || this.lifecycleListeners.set(e, /* @__PURE__ */ new Set());
+      const r = this.lifecycleListeners.get(e);
+      return r.add(s), () => {
+        r.delete(s), r.size === 0 && this.lifecycleListeners.delete(e);
+      };
+    });
+    /**
+     * Get the current state
+     */
+    f(this, "getState", () => p(this, A));
+    /**
+     * Set the state and notify subscribers if the state changes
+     * @param newState The new state to set
+     */
+    f(this, "setState", (e) => {
+      this.emitLifecycle("beforeUpdate", {
+        previousState: p(this, A),
+        nextState: e
+      }), X(p(this, A), e) || (I(this, A, e), I(this, M, Date.now()), this.emitLifecycle("stateChange", { state: e }), this.notifySubscribers(e)), this.emitLifecycle("afterUpdate", { state: e });
+    });
+    f(this, "setStatePartial", (e) => {
+      if (e == null) return;
+      const s = { ...p(this, A), ...e };
+      this.setState(s);
+    });
+    /**
+     * Clear all subscriptions
+     */
+    f(this, "clear", () => {
+      this.emitLifecycle(
+        "destroy"
+        /* DESTROY */
+      ), this.subscribers = /* @__PURE__ */ new Set(), this.lifecycleListeners = /* @__PURE__ */ new Map();
+    });
+    f(this, "reset", () => {
+      this.setState(this.initialState);
+    });
+    f(this, "lastUpdated", () => p(this, M));
+    I(this, A, e), this.initialState = e, I(this, M, Date.now()), this.emitLifecycle("init", { initialState: p(this, A) });
+  }
+}
+A = new WeakMap(), M = new WeakMap();
+function we(t) {
+  return new R(t);
+}
+function w(t) {
+  if (!t) return !1;
+  try {
+    return typeof t.isAvailable == "function" ? t.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function H(t, e) {
+  try {
+    return { success: !0, result: await t(), error: null };
+  } catch (s) {
+    return {
+      success: !1,
+      result: null,
+      error: {
+        message: s instanceof Error ? s.message || "Unknown error" : (s == null ? void 0 : s.toString()) || "Unknown error",
+        code: "STORAGE_OPERATION_FAILED",
+        context: e
+      }
+    };
+  }
+}
+function Ae(t = {}) {
+  const {
+    level: e = "info",
+    prefix: s = "[openCx]",
+    enabled: r = !0
+  } = t;
+  let u = e;
+  const d = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  function g(n) {
+    return r && d[n] >= d[u];
+  }
+  function a(n) {
+    return `${s} ${n}`;
+  }
+  function l(n) {
+    return n.map((i) => {
+      if (i instanceof Error)
+        return {
+          name: i.name,
+          message: i.message,
+          stack: i.stack
+        };
+      if (typeof i == "object")
+        try {
+          return JSON.stringify(i, null, 2);
+        } catch {
+          return i;
+        }
+      return i;
+    });
+  }
+  return {
+    debug(n, ...i) {
+      g("debug") && console.debug(a(n), ...l(i));
+    },
+    info(n, ...i) {
+      g("info") && console.info(a(n), ...l(i));
+    },
+    warn(n, ...i) {
+      g("warn") && console.warn(a(n), ...l(i));
+    },
+    error(n, ...i) {
+      g("error") && console.error(a(n), ...l(i));
+    },
+    setLevel(n) {
+      u = n;
+    }
+  };
+}
+function Z(t) {
+  if (!t) return !1;
+  try {
+    return typeof t.isAvailable == "function" ? t.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function ee(t, e) {
+  try {
+    return await t(), { success: !0, error: null };
+  } catch (s) {
+    return {
+      success: !1,
+      error: {
+        message: s instanceof Error ? s.message || "Unknown error" : (s == null ? void 0 : s.toString()) || "Unknown error",
+        code: "AUDIO_OPERATION_FAILED",
+        context: e
+      }
+    };
+  }
+}
+function k() {
+  return J();
+}
+function te({ config: t, api: e }, s) {
+  const r = new R({
+    contact: null,
+    loading: { isLoading: !1, reason: null },
+    error: { hasError: !1 }
+  });
+  function u() {
+    var l;
+    return !((l = r.getState().contact) != null && l.contactId) && t.getConfig().collectUserData ? {
+      should: !0,
+      reason: "No contact id and collectUserData is true"
+    } : {
+      should: !1
+    };
+  }
+  async function d() {
+    try {
+      r.setStatePartial({
+        loading: { isLoading: !0, reason: "cleaning_up" },
+        error: { hasError: !1 }
+      }), r.setState({
+        contact: null,
+        loading: { isLoading: !1, reason: null },
+        error: { hasError: !1 }
+      }), r.clear();
+    } catch (a) {
+      r.setStatePartial({
+        error: {
+          hasError: !0,
+          message: a instanceof Error ? a.message : "Failed to cleanup contact data",
+          code: "CONTACT_CLEANUP_FAILED"
+        }
+      });
+    } finally {
+      r.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  async function g(a) {
+    r.setStatePartial({
+      loading: { isLoading: !0, reason: "creating_unauthenticated_contact" },
+      error: { hasError: !1 }
+    });
+    const { data: l, error: n } = await e.createContact(a);
+    return l != null && l.contactId ? (r.setStatePartial({
+      contact: {
+        authenticationStatus: {
+          is: !1
+        },
+        contactId: l.contactId,
+        contactName: l.contactName
+      }
+    }), e.setUser({ email: a.email, name: a.name }), l) : (n && r.setStatePartial({
+      loading: { isLoading: !1, reason: null },
+      error: { hasError: !0, message: n == null ? void 0 : n.message, code: "CONTACT_CREATION_FAILED" }
+    }), null);
+  }
+  return {
+    contactState: r,
+    shouldCollectData: u,
+    cleanup: d,
+    createUnauthenticatedContact: g
+  };
+}
+const x = {
+  SESSION: 1e3,
+  MESSAGES: 1e3
+};
+function se(t) {
+  const e = {
+    id: t.publicId,
+    timestamp: t.sentAt || "",
+    attachments: t.attachments || void 0
+  };
+  return t.sender.kind === "user" ? {
+    ...e,
+    type: "FROM_USER",
+    content: t.content.text || "",
+    deliveredAt: t.sentAt || ""
+  } : t.sender.kind === "agent" ? {
+    id: t.publicId,
+    type: "FROM_AGENT",
+    component: "agent_message",
+    data: {
+      message: t.content.text || ""
+    },
+    timestamp: t.sentAt || "",
+    attachments: t.attachments || void 0
+  } : {
+    ...e,
+    type: "FROM_BOT",
+    component: "bot_message",
+    agent: {
+      id: null,
+      name: t.sender.name || "",
+      isAi: t.sender.kind === "ai",
+      avatar: t.sender.avatar || null
+    },
+    data: {
+      message: t.content.text
+    }
+  };
+}
+function re(t, e, s, r, u) {
+  async function d(n) {
+    var v;
+    const i = e.getState().messages, O = (v = e.getState().messages.at(-1)) == null ? void 0 : v.timestamp, { data: S } = await t.getSessionHistory(
+      n.id,
+      O
+    );
+    if (S && S.length > 0) {
+      const b = S.map(se).filter(
+        (P) => !i.some((y) => y.id === P.id)
+      );
+      b.length > 0 && (s == null || s.debug("Adding new messages to state", {
+        count: b.length,
+        messageIds: b.map((y) => y.id),
+        messageTypes: b.map((y) => y.type)
+      }), r != null && r.getConfig().settings.useSoundEffects && (u != null && u.audio) && Z(u.audio) && b.filter(
+        (E) => E.type === "FROM_BOT"
+      ).length > 0 && await ee(
+        () => u.audio.playNotification(),
+        "Failed to play notification sound for new messages"
+      ), e.setStatePartial({
+        messages: [...i, ...b]
+      }));
+    }
+  }
+  function g(n, i) {
+    return {
+      id: k(),
+      type: "FROM_USER",
+      content: n,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attachments: i,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  function a(n) {
+    if (n.success && n.autopilotResponse)
+      return {
+        type: "FROM_BOT",
+        id: n.autopilotResponse.id || k(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: "bot_message",
+        data: {
+          message: n.autopilotResponse.value.content
+        }
+      };
+    if (n.success && n.uiResponse) {
+      const i = n.uiResponse.value;
+      return {
+        type: "FROM_BOT",
+        id: k(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: i.name,
+        data: i.request_response
+      };
+    }
+    return null;
+  }
+  function l(n) {
+    return {
+      type: "FROM_BOT",
+      id: k(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: "TEXT",
+      data: {
+        message: n,
+        variant: "error"
+      }
+    };
+  }
+  return {
+    fetchHistoryMessages: d,
+    toUserMessage: g,
+    toBotMessage: a,
+    addErrorMessage: l
+  };
+}
+function ae(t, e, s, r, u, d) {
+  var N, C;
+  let g = null;
+  const a = (N = d.platform) == null ? void 0 : N.logger, l = (C = d.platform) == null ? void 0 : C.storage, n = () => u.getConfig().settings.persistSession;
+  if (n() && !w(l))
+    throw new Q();
+  n() && !u.getConfig().user.external_id && (a == null || a.error(
+    "session persistence is enabled but external id is not defined"
+  ));
+  const { token: i, user: O } = u.getConfig(), S = `${O.external_id ?? O.email ?? "unknown"}:${i}:session`;
+  async function v() {
+    a == null || a.debug("Restoring session from storage", {
+      sessionStorageKey: S,
+      stroageAvailable: w(l)
+    }), w(l) && H(async () => {
+      a == null || a.debug("Attempting to restore session from storage");
+      const o = await l.getItem(S);
+      if (o) {
+        const c = JSON.parse(o);
+        a == null || a.info("Session restored from storage", {
+          sessionId: c.id
+        }), e.setState(c), await r.fetchHistoryMessages(c), P();
+      }
+    }, "Error restoring session from storage");
+  }
+  function b() {
+    a == null || a.debug("Setting up session persistence", {
+      sessionStorageKey: S,
+      stroageAvailable: w(l)
+    }), w(l) && e.subscribe(async (o) => {
+      try {
+        o ? (await l.setItem(S, JSON.stringify(o)), a == null || a.debug("Session persisted to storage", {
+          sessionId: o.id
+        })) : (await l.removeItem(S), a == null || a.debug("Session removed from storage"));
+      } catch (c) {
+        a == null || a.error("Error persisting session:", c), s.setStatePartial({
+          error: {
+            hasError: !0,
+            message: c instanceof Error ? c.message : "Failed to persist session",
+            code: "SESSION_PERSISTENCE_FAILED"
+          }
+        });
+      }
+    });
+  }
+  function P() {
+    if (g) return;
+    a == null || a.debug("Starting polling");
+    const o = [];
+    o.push(
+      setInterval(async () => {
+        const c = e.getState();
+        if (c != null && c.id)
+          try {
+            const m = /* @__PURE__ */ new Date();
+            s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  isPolling: !0,
+                  lastPollTime: m.toISOString(),
+                  nextPollTime: new Date(
+                    m.getTime() + x.SESSION
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            });
+            const { data: G } = await t.getSession(c.id);
+            G && e.setState(G), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  ...s.getState().polling.session,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (m) {
+            a == null || a.error("Error polling session:", m), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  ...s.getState().polling.session,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: m instanceof Error ? m.message : "Failed to poll session",
+                    code: "SESSION_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, x.SESSION)
+    ), o.push(
+      setInterval(async () => {
+        const c = e.getState();
+        if (c != null && c.id)
+          try {
+            const m = /* @__PURE__ */ new Date();
+            s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  isPolling: !0,
+                  lastPollTime: m.toISOString(),
+                  nextPollTime: new Date(
+                    m.getTime() + x.MESSAGES
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            }), await r.fetchHistoryMessages(c), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  ...s.getState().polling.messages,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (m) {
+            a == null || a.error("Error polling messages:", m), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  ...s.getState().polling.messages,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: m instanceof Error ? m.message : "Failed to poll messages",
+                    code: "MESSAGES_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, x.MESSAGES)
+    ), g = () => {
+      a == null || a.debug("Stopping polling"), o.forEach(clearInterval), s.setStatePartial({
+        polling: {
+          session: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          },
+          messages: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          }
+        }
+      });
+    };
+  }
+  async function y() {
+    a == null || a.info("Creating new session"), s.setStatePartial({
+      loading: { isLoading: !0, reason: "creating_session" },
+      error: { hasError: !1 }
+    });
+    const { data: o, error: c } = await t.createSession();
+    if (o)
+      return a == null || a.info("Session created successfully", { sessionId: o.id }), e.setState(o), s.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      }), P(), o;
+    a == null || a.error("Failed to create session:", c);
+    const m = {
+      hasError: !0,
+      message: c instanceof Error ? c.message : "Failed to create session",
+      code: "SESSION_CREATION_FAILED"
+    };
+    return s.setStatePartial({
+      error: m,
+      loading: { isLoading: !1, reason: null }
+    }), null;
+  }
+  async function E() {
+    var c;
+    const o = e.getState();
+    if (o != null && o.id)
+      try {
+        g && (g(), g = null), e.setState(null), n() && l && await l.removeItem(S), s.setState({
+          messages: [],
+          keyboard: null,
+          loading: { isLoading: !1, reason: null },
+          error: { hasError: !1 },
+          polling: {
+            session: {
+              isPolling: !1,
+              lastPollTime: null,
+              nextPollTime: null,
+              error: { hasError: !1 }
+            },
+            messages: {
+              isPolling: !1,
+              lastPollTime: null,
+              nextPollTime: null,
+              error: { hasError: !1 }
+            }
+          }
+        }), (c = d.onSessionDestroy) == null || c.call(d);
+      } catch (m) {
+        s.setStatePartial({
+          error: {
+            hasError: !0,
+            message: m instanceof Error ? m.message : "Failed to clear session",
+            code: "SESSION_CLEAR_FAILED"
+          }
+        });
+      }
+  }
+  function L(o = !1) {
+    try {
+      g && (g(), g = null), o && n() && w(l) && (console.log("removing session data", S), H(
+        () => l.removeItem(S),
+        "Error removing session data"
+      )), s.setState({
+        messages: [],
+        keyboard: null,
+        loading: { isLoading: !1, reason: null },
+        error: { hasError: !1 },
+        polling: {
+          session: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          },
+          messages: {
+            isPolling: !1,
+            lastPollTime: null,
+            nextPollTime: null,
+            error: { hasError: !1 }
+          }
+        }
+      }), e.setState(null), s.clear(), e.clear();
+    } catch (c) {
+      s.setStatePartial({
+        error: {
+          hasError: !0,
+          message: c instanceof Error ? c.message : "Failed to cleanup",
+          code: "SESSION_CLEAR_FAILED"
+        }
+      });
+    }
+  }
+  async function D(o) {
+    return t.getSession(o);
+  }
+  async function T() {
+    const o = e.getState();
+    if (!(o != null && o.id)) return;
+    const { data: c } = await D(o.id);
+    return c && e.setState(c), c;
+  }
+  return n() && w(l) && (a == null || a.debug("Initializing session persistence", {
+    sessionStorageKey: S,
+    stroageAvailable: w(l)
+  }), v(), b()), {
+    createSession: y,
+    clearSession: E,
+    cleanup: L,
+    startPolling: P,
+    fetchSession: D,
+    refetchSession: T,
+    sessionStorageKey: S
+  };
+}
+function Te(t) {
+  var b;
+  const e = (b = t.platform) == null ? void 0 : b.logger, s = {
+    messages: [],
+    keyboard: null,
+    loading: { isLoading: !1, reason: null },
+    error: { hasError: !1 },
+    polling: {
+      session: {
+        isPolling: !1,
+        lastPollTime: null,
+        nextPollTime: null,
+        error: { hasError: !1 }
+      },
+      messages: {
+        isPolling: !1,
+        lastPollTime: null,
+        nextPollTime: null,
+        error: { hasError: !1 }
+      }
+    }
+  }, r = new R(s), {
+    contactState: u,
+    cleanup: d,
+    shouldCollectData: g,
+    createUnauthenticatedContact: a
+  } = te(
+    { config: t.config, api: t.api },
+    t.platform
+  ), l = new R(null), n = re(
+    t.api,
+    r,
+    e,
+    t.config,
+    t.platform
+  ), i = ae(
+    t.api,
+    l,
+    r,
+    n,
+    t.config,
+    t
+  );
+  async function O(P, y) {
+    var D;
+    let E = l.getState(), L = !1;
+    if (!(E != null && E.id)) {
+      if (e == null || e.debug("No active session, creating new session"), E = await i.createSession(), !E)
+        return {
+          success: !1,
+          createdSession: L
+        };
+      L = !0;
+    }
+    E.assignee.kind === "ai" && (E = await i.refetchSession() ?? E);
+    try {
+      e == null || e.debug("Sending message", { sessionId: E.id }), E.assignee.kind === "ai" ? r.setStatePartial({
+        loading: { isLoading: !0, reason: "sending_message_to_bot" },
+        error: { hasError: !1 }
+      }) : r.setStatePartial({
+        loading: { isLoading: !0, reason: "sending_message_to_agent" },
+        error: { hasError: !1 }
+      });
+      const T = n.toUserMessage(
+        P.content,
+        P.attachments || void 0
+      ), N = r.getState().messages;
+      r.setStatePartial({
+        messages: [...N, T]
+      });
+      const C = t.config.getConfig(), { data: o } = await t.api.handleMessage(
+        {
+          uuid: T.id,
+          bot_token: C.token,
+          headers: C.headers,
+          query_params: C.queryParams,
+          session_id: E.id,
+          user: C.user,
+          ...P
+        },
+        y
+      );
+      if (o != null && o.success) {
+        e == null || e.debug("Message sent successfully");
+        const c = n.toBotMessage(o);
+        if (c) {
+          const m = r.getState().messages;
+          r.setStatePartial({
+            messages: [...m, c]
+          });
+        }
+        return {
+          success: !0,
+          createdSession: L,
+          botMessage: c
+        };
+      } else {
+        e == null || e.warn("Message send failed", o == null ? void 0 : o.error);
+        const c = n.addErrorMessage(
+          ((D = o == null ? void 0 : o.error) == null ? void 0 : D.message) || "Unknown error occurred"
+        ), m = r.getState().messages;
+        return r.setStatePartial({
+          messages: [...m, c]
+        }), {
+          success: !1,
+          createdSession: L,
+          error: o == null ? void 0 : o.error
+        };
+      }
+    } catch (T) {
+      return e == null || e.error("Error sending message:", T), r.setStatePartial({
+        error: {
+          hasError: !0,
+          message: T instanceof Error ? T.message : "Failed to send message",
+          code: "MESSAGE_SEND_FAILED"
+        }
+      }), {
+        success: !1,
+        createdSession: L,
+        error: T
+      };
+    } finally {
+      r.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  async function S() {
+    await i.clearSession(), await i.createSession();
+  }
+  const v = () => {
+    d(), i.cleanup();
+  };
+  return {
+    chatState: r,
+    sessionState: l,
+    sendMessage: O,
+    createSession: i.createSession,
+    clearSession: i.clearSession,
+    cleanup: v,
+    initialState: s,
+    sessionStorageKey: i.sessionStorageKey,
+    recreateSession: S,
+    contactState: u,
+    contactManager: {
+      shouldCollectData: g,
+      createUnauthenticatedContact: a
+    }
+  };
+}
+const ne = {
+  messageArrived: "https://cloud.opencopilot.so/sfx/notification3.mp3"
+}, ie = {
+  primaryColor: "hsl(211,65%,59%)",
+  triggerOffset: "20px"
+}, $ = {
+  persistSession: !1,
+  useSoundEffects: !1
+}, oe = 1e3 * 3;
+function le(t, e, s) {
+  const r = e.logger, u = e.storage;
+  let d = t ?? $;
+  async function g() {
+    if (!(!u || !w(u)))
+      try {
+        r == null || r.debug("Attempting to restore settings from storage");
+        const i = await u.getItem(s);
+        i && (d = JSON.parse(i), r == null || r.debug("Settings restored from storage", d));
+      } catch (i) {
+        r == null || r.error("Error restoring settings:", i);
+      }
+  }
+  async function a(i) {
+    if (!(!u || !w(u)))
+      try {
+        await u.setItem(s, JSON.stringify(i)), r == null || r.debug("Settings persisted to storage", i);
+      } catch (O) {
+        r == null || r.error("Error persisting settings:", O);
+      }
+  }
+  function l(i) {
+    d = {
+      ...d,
+      ...i
+    }, a(d);
+  }
+  function n() {
+    return d;
+  }
+  return g(), {
+    getSettings: n,
+    updateSettings: l
+  };
+}
+function Ie(t, e) {
+  var g, a, l, n, i;
+  if (!t.token)
+    throw new Error("Token is required");
+  if (t.pollingInterval && t.pollingInterval < oe)
+    throw new Error("Polling interval must be at least 3 seconds");
+  const s = {
+    ...t,
+    collectUserData: t.collectUserData ?? !1,
+    initialMessages: t.initialMessages ?? [],
+    apiUrl: t.apiUrl ?? "https://api.open.cx",
+    pollingInterval: t.pollingInterval ?? 3e3,
+    headers: t.headers ?? {},
+    queryParams: t.queryParams ?? {},
+    pathParams: t.pathParams ?? {},
+    bot: {
+      name: ((g = t.bot) == null ? void 0 : g.name) ?? "Bot",
+      avatar: ((a = t.bot) == null ? void 0 : a.avatar) ?? null,
+      id: ((l = t.bot) == null ? void 0 : l.id) ?? null,
+      isAi: ((n = t.bot) == null ? void 0 : n.isAi) ?? !0
+    },
+    contactToken: t.contactToken,
+    debug: t.debug ?? !1,
+    language: t.language ?? "en",
+    user: t.user ?? {},
+    soundEffectFiles: Object.assign({}, ne, t.soundEffectFiles),
+    theme: Object.assign({}, ie, t.theme),
+    settings: Object.assign({}, $, t.settings),
+    assets: {
+      organizationLogo: ((i = t.assets) == null ? void 0 : i.organizationLogo) ?? ""
+    }
+  }, r = `${s.token}:settings`, { getSettings: u, updateSettings: d } = le(s.settings, e, r);
+  return {
+    config: s,
+    updateSettings: d,
+    getConfig: () => ({
+      ...s,
+      settings: u()
+    }),
+    getApiConfig: () => ({
+      apiUrl: s.apiUrl,
+      token: s.token,
+      headers: s.headers,
+      queryParams: s.queryParams,
+      pathParams: s.pathParams
+    }),
+    getBotConfig: () => s.bot,
+    getThemeConfig: () => s.theme,
+    getSoundEffects: () => s.soundEffectFiles,
+    getUser: () => s.user,
+    getLanguage: () => s.language,
+    getDebugMode: () => s.debug
+  };
+}
+const ce = (t) => {
+  console.log(t.error);
+}, ue = (t) => {
+  const e = K({
+    baseUrl: t.baseUrl
+  }), s = {
+    onRequest: t.onRequest,
+    onResponse: t.onResponse,
+    onError: t.onError || ce
+  };
+  return e.use(s), e;
+};
+var h, U;
+class Oe {
+  constructor(e) {
+    F(this, h);
+    F(this, U);
+    f(this, "constructClientOptions", (e) => {
+      const s = {
+        claim: "",
+        value: ""
+      };
+      e != null && e.email ? (s.claim = "email", s.value = e.email) : e != null && e.phone && (s.claim = "phone", s.value = e.phone);
+      const r = this.options.config.apiUrl, u = {
+        "X-Bot-Token": this.options.config.token,
+        "X-Consumer-Id": `${s.claim}:${s.value}`,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        Authorization: this.options.config.contactToken ? `Bearer ${this.options.config.contactToken}` : void 0
+      };
+      return { baseUrl: r, headers: u };
+    });
+    f(this, "createOpenAPIClient", ({
+      baseUrl: e,
+      headers: s
+    }) => ue({
+      baseUrl: e,
+      onRequest: ({ request: r }) => {
+        Object.entries(s).forEach(([u, d]) => {
+          d && r.headers.set(u, d);
+        });
+      }
+    }));
+    f(this, "createAxiosUploadClient", ({
+      baseUrl: e,
+      headers: s
+    }) => V.create({
+      baseURL: `${e}/backend/widget/v2/upload`,
+      headers: s
+    }));
+    f(this, "setUser", (e) => {
+      const { baseUrl: s, headers: r } = this.constructClientOptions(e);
+      I(this, h, this.createOpenAPIClient({ baseUrl: s, headers: r })), I(this, U, this.createAxiosUploadClient({ baseUrl: s, headers: r }));
+    });
+    f(this, "me", async () => await p(this, h).GET("/backend/widget/v2/me"));
+    f(this, "widgetPrelude", async () => await p(this, h).GET("/backend/widget/v2/prelude", {
+      params: { header: { "X-Bot-Token": this.options.config.token } }
+    }));
+    f(this, "handleMessage", async (e, s) => await p(this, h).POST("/backend/widget/v2/chat/send", {
+      body: e,
+      signal: s
+    }));
+    f(this, "getSessionHistory", async (e, s) => {
+      const r = s ? { lastMessageTimestamp: s } : void 0;
+      return await p(this, h).GET(
+        "/backend/widget/v2/session/history/{sessionId}",
+        { params: { path: { sessionId: e }, query: r } }
+      );
+    });
+    f(this, "createContact", async (e) => await p(this, h).POST("/backend/widget/v2/me/create", {
+      params: { header: { "x-bot-token": this.options.config.token } },
+      body: e
+    }));
+    f(this, "createSession", async () => await p(this, h).POST("/backend/widget/v2/create-session"));
+    f(this, "getSession", async (e) => await p(this, h).GET("/backend/widget/v2/session/{sessionId}", {
+      params: { path: { sessionId: e } }
+    }));
+    f(this, "uploadFile", async (e, s = {}) => {
+      const r = new FormData();
+      r.append("file", e.file);
+      const { data: u } = await p(this, U).post(
+        "",
+        r,
+        {
+          headers: {
+            "Content-Type": "multipart/form-data"
+          },
+          ...s
+        }
+      );
+      return u;
+    });
+    f(this, "vote", async (e) => await p(this, h).POST("/backend/widget/v2/chat/vote", { body: e }));
+    this.options = e;
+    const { baseUrl: s, headers: r } = this.constructClientOptions(
+      e.config.user
+    );
+    I(this, h, this.createOpenAPIClient({ baseUrl: s, headers: r })), I(this, U, this.createAxiosUploadClient({ baseUrl: s, headers: r }));
+  }
+}
+h = new WeakMap(), U = new WeakMap();
+export {
+  Oe as A,
+  pe as C,
+  ye as E,
+  Pe as F,
+  W as L,
+  _ as O,
+  R as P,
+  Y as S,
+  be as T,
+  te as a,
+  Ie as b,
+  Te as c,
+  Ae as d,
+  Ee as e,
+  he as f,
+  Q as g,
+  we as h,
+  w as i,
+  Z as j,
+  ee as k,
+  H as s
+};
+//# sourceMappingURL=api-CAm3rFZk.js.map