@opencx/widget 2.6.0 → 2.6.2

package/dist/api-Cez5T-se.js

@@ -0,0 +1,1393 @@
+var ne = Object.defineProperty;
+var Q = (t) => {
+  throw TypeError(t);
+};
+var ae = (t, e, s) => e in t ? ne(t, e, { enumerable: !0, configurable: !0, writable: !0, value: s }) : t[e] = s;
+var S = (t, e, s) => ae(t, typeof e != "symbol" ? e + "" : e, s), V = (t, e, s) => e.has(t) || Q("Cannot " + s);
+var y = (t, e, s) => (V(t, e, "read from private field"), s ? s.call(t) : e.get(t)), G = (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), F = (t, e, s, r) => (V(t, e, "write to private field"), r ? r.call(t, s) : e.set(t, s), s);
+import ie from "lodash.isequal";
+import { v4 as oe } from "uuid";
+class N extends Error {
+  constructor(e) {
+    super(e), this.name = "OpenCXError";
+  }
+}
+class xe extends N {
+  constructor(e = "Connection failed") {
+    super(e), this.name = "ConnectionError";
+  }
+}
+class Me extends N {
+  constructor(e = "Authentication failed") {
+    super(e), this.name = "AuthenticationError";
+  }
+}
+class le extends N {
+  constructor(e = "Session error occurred") {
+    super(e), this.name = "SessionError";
+  }
+}
+class Fe extends le {
+  constructor(e = "Session not defined") {
+    super(e), this.name = "SessionNotDefinedError";
+  }
+}
+class Ne extends N {
+  constructor(e = "Transport error occurred") {
+    super(e), this.name = "TransportError";
+  }
+}
+class ke extends N {
+  constructor(e = "File upload failed") {
+    super(e), this.name = "FileUploadError";
+  }
+}
+class ce extends N {
+  constructor(e = "Storage is not available") {
+    super(e), this.name = "StorageNotAvailableError";
+  }
+}
+class je extends N {
+  constructor(e = "External ID is not defined") {
+    super(e), this.name = "ExternalIdNotDefinedError";
+  }
+}
+var ue = /* @__PURE__ */ ((t) => (t.INIT = "init", t.STATE_CHANGE = "stateChange", t.BEFORE_UPDATE = "beforeUpdate", t.AFTER_UPDATE = "afterUpdate", t.DESTROY = "destroy", t.ERROR = "error", t))(ue || {}), _, k;
+class X {
+  constructor(e) {
+    S(this, "subscribers", /* @__PURE__ */ new Set());
+    G(this, _);
+    S(this, "initialState");
+    G(this, k);
+    S(this, "lifecycleListeners", /* @__PURE__ */ new Map());
+    S(this, "emitLifecycle", (e, s) => {
+      const r = this.lifecycleListeners.get(e);
+      if (r) {
+        const a = {
+          type: e,
+          timestamp: Date.now(),
+          data: s
+        };
+        r.forEach((l) => {
+          try {
+            l(a);
+          } catch {
+          }
+        });
+      }
+    });
+    S(this, "notifySubscribers", (e) => {
+      Array.from(this.subscribers).forEach((r) => {
+        try {
+          r(e);
+        } catch (a) {
+          this.emitLifecycle("error", { error: a });
+        }
+      });
+    });
+    /**
+     * Subscribe to state changes
+     * @param callback Function to call when state changes
+     * @returns Unsubscribe function
+     */
+    S(this, "subscribe", (e) => (this.subscribers.add(e), () => {
+      this.subscribers.delete(e);
+    }));
+    S(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
+     */
+    S(this, "getState", () => y(this, _));
+    /**
+     * Set the state and notify subscribers if the state changes
+     * @param newState The new state to set
+     */
+    S(this, "setState", (e) => {
+      this.emitLifecycle("beforeUpdate", {
+        previousState: y(this, _),
+        nextState: e
+      }), ie(y(this, _), e) || (F(this, _, e), F(this, k, Date.now()), this.emitLifecycle("stateChange", { state: e }), this.notifySubscribers(e)), this.emitLifecycle("afterUpdate", { state: e });
+    });
+    S(this, "setStatePartial", (e) => {
+      if (e == null) return;
+      const s = { ...y(this, _), ...e };
+      this.setState(s);
+    });
+    /**
+     * Clear all subscriptions
+     */
+    S(this, "clear", () => {
+      this.emitLifecycle(
+        "destroy"
+        /* DESTROY */
+      ), this.subscribers = /* @__PURE__ */ new Set(), this.lifecycleListeners = /* @__PURE__ */ new Map();
+    });
+    S(this, "reset", () => {
+      this.setState(this.initialState);
+    });
+    S(this, "lastUpdated", () => y(this, k));
+    F(this, _, e), this.initialState = e, F(this, k, Date.now()), this.emitLifecycle("init", { initialState: y(this, _) });
+  }
+}
+_ = new WeakMap(), k = new WeakMap();
+function qe(t) {
+  return new X(t);
+}
+function U(t) {
+  if (!t) return !1;
+  try {
+    return typeof t.isAvailable == "function" ? t.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function Y(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 $e(t = {}) {
+  const {
+    level: e = "info",
+    prefix: s = "[openCx]",
+    enabled: r = !0
+  } = t;
+  let a = e;
+  const l = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3
+  };
+  function c(i) {
+    return r && l[i] >= l[a];
+  }
+  function n(i) {
+    return `${s} ${i}`;
+  }
+  function d(i) {
+    return i.map((o) => {
+      if (o instanceof Error)
+        return {
+          name: o.name,
+          message: o.message,
+          stack: o.stack
+        };
+      if (typeof o == "object")
+        try {
+          return JSON.stringify(o, null, 2);
+        } catch {
+          return o;
+        }
+      return o;
+    });
+  }
+  return {
+    debug(i, ...o) {
+      c("debug") && console.debug(n(i), ...d(o));
+    },
+    info(i, ...o) {
+      c("info") && console.info(n(i), ...d(o));
+    },
+    warn(i, ...o) {
+      c("warn") && console.warn(n(i), ...d(o));
+    },
+    error(i, ...o) {
+      c("error") && console.error(n(i), ...d(o));
+    },
+    setLevel(i) {
+      a = i;
+    }
+  };
+}
+function fe(t) {
+  if (!t) return !1;
+  try {
+    return typeof t.isAvailable == "function" ? t.isAvailable() : !0;
+  } catch {
+    return !1;
+  }
+}
+async function de(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 B() {
+  return oe();
+}
+function ge({ config: t, api: e }, s) {
+  const r = new X({
+    contact: null,
+    loading: { isLoading: !1, reason: null },
+    error: { hasError: !1 }
+  });
+  function a() {
+    var d;
+    return !((d = r.getState().contact) != null && d.contactId) && t.getConfig().collectUserData ? {
+      should: !0,
+      reason: "No contact id and collectUserData is true"
+    } : {
+      should: !1
+    };
+  }
+  async function l() {
+    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 (n) {
+      r.setStatePartial({
+        error: {
+          hasError: !0,
+          message: n instanceof Error ? n.message : "Failed to cleanup contact data",
+          code: "CONTACT_CLEANUP_FAILED"
+        }
+      });
+    } finally {
+      r.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  async function c(n) {
+    r.setStatePartial({
+      loading: { isLoading: !0, reason: "creating_unauthenticated_contact" },
+      error: { hasError: !1 }
+    });
+    const { data: d, error: i } = await e.createContact(n);
+    return d != null && d.contactId ? (r.setStatePartial({
+      contact: {
+        authenticationStatus: {
+          is: !1
+        },
+        contactId: d.contactId,
+        contactName: d.contactName
+      }
+    }), e.setUser({ email: n.email, name: n.name }), d) : (i && r.setStatePartial({
+      loading: { isLoading: !1, reason: null },
+      error: { hasError: !0, message: i == null ? void 0 : i.message, code: "CONTACT_CREATION_FAILED" }
+    }), null);
+  }
+  return {
+    contactState: r,
+    shouldCollectData: a,
+    cleanup: l,
+    createUnauthenticatedContact: c
+  };
+}
+const J = {
+  SESSION: 1e4,
+  // every 10 seconds
+  MESSAGES: 5e3
+  // every 5 seconds
+};
+function me(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 Se(t, e, s, r, a) {
+  async function l(i) {
+    var b;
+    const o = e.getState().messages, m = (b = e.getState().messages.at(-1)) == null ? void 0 : b.timestamp, { data: f } = await t.getSessionHistory(
+      i.id,
+      m
+    );
+    if (f && f.length > 0) {
+      const w = f.map(me).filter(
+        (R) => !o.some((I) => I.id === R.id)
+      );
+      w.length > 0 && (s == null || s.debug("Adding new messages to state", {
+        count: w.length,
+        messageIds: w.map((I) => I.id),
+        messageTypes: w.map((I) => I.type)
+      }), r != null && r.getConfig().settings.useSoundEffects && (a != null && a.audio) && fe(a.audio) && w.filter(
+        (p) => p.type === "FROM_BOT"
+      ).length > 0 && await de(
+        () => a.audio.playNotification(),
+        "Failed to play notification sound for new messages"
+      ), e.setStatePartial({
+        messages: [...o, ...w]
+      }));
+    }
+  }
+  function c(i, o) {
+    return {
+      id: B(),
+      type: "FROM_USER",
+      content: i,
+      deliveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attachments: o,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  function n(i) {
+    if (i.success && i.autopilotResponse)
+      return {
+        type: "FROM_BOT",
+        id: i.autopilotResponse.id || B(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: "bot_message",
+        data: {
+          message: i.autopilotResponse.value.content
+        }
+      };
+    if (i.success && i.uiResponse) {
+      const o = i.uiResponse.value;
+      return {
+        type: "FROM_BOT",
+        id: B(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        component: o.name,
+        data: o.request_response
+      };
+    }
+    return null;
+  }
+  function d(i) {
+    return {
+      type: "FROM_BOT",
+      id: B(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      component: "TEXT",
+      data: {
+        message: i,
+        variant: "error"
+      }
+    };
+  }
+  return {
+    fetchHistoryMessages: l,
+    toUserMessage: c,
+    toBotMessage: n,
+    addErrorMessage: d
+  };
+}
+function he(t, e, s, r, a, l) {
+  var D, L;
+  let c = null;
+  const n = (D = l.platform) == null ? void 0 : D.logger, d = (L = l.platform) == null ? void 0 : L.storage, i = () => a.getConfig().settings.persistSession;
+  if (i() && !U(d))
+    throw new ce();
+  i() && !a.getConfig().user.external_id && (n == null || n.error(
+    "session persistence is enabled but external id is not defined"
+  ));
+  const { token: o, user: m } = a.getConfig(), f = `${m.external_id ?? m.email ?? "unknown"}:${o}:session`;
+  async function b() {
+    n == null || n.debug("Restoring session from storage", {
+      sessionStorageKey: f,
+      stroageAvailable: U(d)
+    }), U(d) && Y(async () => {
+      n == null || n.debug("Attempting to restore session from storage");
+      const u = await d.getItem(f);
+      if (u) {
+        const g = JSON.parse(u);
+        n == null || n.info("Session restored from storage", {
+          sessionId: g.id
+        }), e.setState(g), await r.fetchHistoryMessages(g), R();
+      }
+    }, "Error restoring session from storage");
+  }
+  function w() {
+    n == null || n.debug("Setting up session persistence", {
+      sessionStorageKey: f,
+      stroageAvailable: U(d)
+    }), U(d) && e.subscribe(async (u) => {
+      try {
+        u ? (await d.setItem(f, JSON.stringify(u)), n == null || n.debug("Session persisted to storage", {
+          sessionId: u.id
+        })) : (await d.removeItem(f), n == null || n.debug("Session removed from storage"));
+      } catch (g) {
+        n == null || n.error("Error persisting session:", g), s.setStatePartial({
+          error: {
+            hasError: !0,
+            message: g instanceof Error ? g.message : "Failed to persist session",
+            code: "SESSION_PERSISTENCE_FAILED"
+          }
+        });
+      }
+    });
+  }
+  function R() {
+    if (c) return;
+    n == null || n.debug("Starting polling");
+    const u = [];
+    u.push(
+      setInterval(async () => {
+        const g = e.getState();
+        if (g != null && g.id)
+          try {
+            const h = /* @__PURE__ */ new Date();
+            s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  isPolling: !0,
+                  lastPollTime: h.toISOString(),
+                  nextPollTime: new Date(
+                    h.getTime() + J.SESSION
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            });
+            const { data: q } = await t.getSession(g.id);
+            q && e.setState(q), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  ...s.getState().polling.session,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (h) {
+            n == null || n.error("Error polling session:", h), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                session: {
+                  ...s.getState().polling.session,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: h instanceof Error ? h.message : "Failed to poll session",
+                    code: "SESSION_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, J.SESSION)
+    ), u.push(
+      setInterval(async () => {
+        const g = e.getState();
+        if (g != null && g.id)
+          try {
+            const h = /* @__PURE__ */ new Date();
+            s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  isPolling: !0,
+                  lastPollTime: h.toISOString(),
+                  nextPollTime: new Date(
+                    h.getTime() + J.MESSAGES
+                  ).toISOString(),
+                  error: { hasError: !1 }
+                }
+              }
+            }), await r.fetchHistoryMessages(g), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  ...s.getState().polling.messages,
+                  isPolling: !1
+                }
+              }
+            });
+          } catch (h) {
+            n == null || n.error("Error polling messages:", h), s.setStatePartial({
+              polling: {
+                ...s.getState().polling,
+                messages: {
+                  ...s.getState().polling.messages,
+                  isPolling: !1,
+                  error: {
+                    hasError: !0,
+                    message: h instanceof Error ? h.message : "Failed to poll messages",
+                    code: "MESSAGES_POLLING_FAILED"
+                  }
+                }
+              }
+            });
+          }
+      }, J.MESSAGES)
+    ), c = () => {
+      n == null || n.debug("Stopping polling"), u.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 I() {
+    n == null || n.info("Creating new session"), s.setStatePartial({
+      loading: { isLoading: !0, reason: "creating_session" },
+      error: { hasError: !1 }
+    });
+    const { data: u, error: g } = await t.createSession();
+    if (u)
+      return n == null || n.info("Session created successfully", { sessionId: u.id }), e.setState(u), s.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      }), R(), u;
+    n == null || n.error("Failed to create session:", g);
+    const h = {
+      hasError: !0,
+      message: g instanceof Error ? g.message : "Failed to create session",
+      code: "SESSION_CREATION_FAILED"
+    };
+    return s.setStatePartial({
+      error: h,
+      loading: { isLoading: !1, reason: null }
+    }), null;
+  }
+  async function p() {
+    var g;
+    const u = e.getState();
+    if (u != null && u.id)
+      try {
+        c && (c(), c = null), e.setState(null), i() && d && await d.removeItem(f), 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 }
+            }
+          }
+        }), (g = l.onSessionDestroy) == null || g.call(l);
+      } catch (h) {
+        s.setStatePartial({
+          error: {
+            hasError: !0,
+            message: h instanceof Error ? h.message : "Failed to clear session",
+            code: "SESSION_CLEAR_FAILED"
+          }
+        });
+      }
+  }
+  function C(u = !1) {
+    try {
+      c && (c(), c = null), u && i() && U(d) && (console.log("removing session data", f), Y(
+        () => d.removeItem(f),
+        "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 (g) {
+      s.setStatePartial({
+        error: {
+          hasError: !0,
+          message: g instanceof Error ? g.message : "Failed to cleanup",
+          code: "SESSION_CLEAR_FAILED"
+        }
+      });
+    }
+  }
+  async function v(u) {
+    return t.getSession(u);
+  }
+  async function O() {
+    const u = e.getState();
+    if (!(u != null && u.id)) return;
+    const { data: g } = await v(u.id);
+    return g && e.setState(g), g;
+  }
+  return i() && U(d) && (n == null || n.debug("Initializing session persistence", {
+    sessionStorageKey: f,
+    stroageAvailable: U(d)
+  }), b(), w()), {
+    createSession: I,
+    clearSession: p,
+    cleanup: C,
+    startPolling: R,
+    fetchSession: v,
+    refetchSession: O,
+    sessionStorageKey: f
+  };
+}
+function ze(t) {
+  var w;
+  const e = (w = t.platform) == null ? void 0 : w.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 X(s), {
+    contactState: a,
+    cleanup: l,
+    shouldCollectData: c,
+    createUnauthenticatedContact: n
+  } = ge(
+    { config: t.config, api: t.api },
+    t.platform
+  ), d = new X(null), i = Se(
+    t.api,
+    r,
+    e,
+    t.config,
+    t.platform
+  ), o = he(
+    t.api,
+    d,
+    r,
+    i,
+    t.config,
+    t
+  );
+  async function m(R, I) {
+    var v;
+    let p = d.getState(), C = !1;
+    if (!(p != null && p.id)) {
+      if (e == null || e.debug("No active session, creating new session"), p = await o.createSession(), !p)
+        return {
+          success: !1,
+          createdSession: C
+        };
+      C = !0;
+    }
+    p.assignee.kind === "ai" && (p = await o.refetchSession() ?? p);
+    try {
+      e == null || e.debug("Sending message", { sessionId: p.id }), p.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 O = i.toUserMessage(
+        R.content,
+        R.attachments || void 0
+      ), D = r.getState().messages;
+      r.setStatePartial({
+        messages: [...D, O]
+      });
+      const L = t.config.getConfig(), { data: u } = await t.api.handleMessage(
+        {
+          uuid: O.id,
+          bot_token: L.token,
+          headers: L.headers,
+          query_params: L.queryParams,
+          session_id: p.id,
+          user: L.user,
+          ...R
+        },
+        I
+      );
+      if (u != null && u.success) {
+        e == null || e.debug("Message sent successfully");
+        const g = i.toBotMessage(u);
+        if (g) {
+          const h = r.getState().messages;
+          r.setStatePartial({
+            messages: [...h, g]
+          });
+        }
+        return {
+          success: !0,
+          createdSession: C,
+          botMessage: g
+        };
+      } else {
+        e == null || e.warn("Message send failed", u == null ? void 0 : u.error);
+        const g = i.addErrorMessage(
+          ((v = u == null ? void 0 : u.error) == null ? void 0 : v.message) || "Unknown error occurred"
+        ), h = r.getState().messages;
+        return r.setStatePartial({
+          messages: [...h, g]
+        }), {
+          success: !1,
+          createdSession: C,
+          error: u == null ? void 0 : u.error
+        };
+      }
+    } catch (O) {
+      return e == null || e.error("Error sending message:", O), r.setStatePartial({
+        error: {
+          hasError: !0,
+          message: O instanceof Error ? O.message : "Failed to send message",
+          code: "MESSAGE_SEND_FAILED"
+        }
+      }), {
+        success: !1,
+        createdSession: C,
+        error: O
+      };
+    } finally {
+      r.setStatePartial({
+        loading: { isLoading: !1, reason: null }
+      });
+    }
+  }
+  async function f() {
+    await o.clearSession(), await o.createSession();
+  }
+  const b = () => {
+    l(), o.cleanup();
+  };
+  return {
+    chatState: r,
+    sessionState: d,
+    sendMessage: m,
+    createSession: o.createSession,
+    clearSession: o.clearSession,
+    cleanup: b,
+    initialState: s,
+    sessionStorageKey: o.sessionStorageKey,
+    recreateSession: f,
+    contactState: a,
+    contactManager: {
+      shouldCollectData: c,
+      createUnauthenticatedContact: n
+    }
+  };
+}
+const pe = {
+  messageArrived: "https://cloud.opencopilot.so/sfx/notification3.mp3"
+}, Ee = {
+  primaryColor: "hsl(211,65%,59%)",
+  triggerOffset: "20px"
+}, te = {
+  persistSession: !1,
+  useSoundEffects: !1
+}, ye = 1e3 * 3;
+function be(t, e, s) {
+  const r = e.logger, a = e.storage;
+  let l = t ?? te;
+  async function c() {
+    if (!(!a || !U(a)))
+      try {
+        r == null || r.debug("Attempting to restore settings from storage");
+        const o = await a.getItem(s);
+        o && (l = JSON.parse(o), r == null || r.debug("Settings restored from storage", l));
+      } catch (o) {
+        r == null || r.error("Error restoring settings:", o);
+      }
+  }
+  async function n(o) {
+    if (!(!a || !U(a)))
+      try {
+        await a.setItem(s, JSON.stringify(o)), r == null || r.debug("Settings persisted to storage", o);
+      } catch (m) {
+        r == null || r.error("Error persisting settings:", m);
+      }
+  }
+  function d(o) {
+    l = {
+      ...l,
+      ...o
+    }, n(l);
+  }
+  function i() {
+    return l;
+  }
+  return c(), {
+    getSettings: i,
+    updateSettings: d
+  };
+}
+function He(t, e) {
+  var c, n, d, i, o;
+  if (!t.token)
+    throw new Error("Token is required");
+  if (t.pollingInterval && t.pollingInterval < ye)
+    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: ((c = t.bot) == null ? void 0 : c.name) ?? "Bot",
+      avatar: ((n = t.bot) == null ? void 0 : n.avatar) ?? null,
+      id: ((d = t.bot) == null ? void 0 : d.id) ?? null,
+      isAi: ((i = t.bot) == null ? void 0 : i.isAi) ?? !0
+    },
+    contactToken: t.contactToken,
+    debug: t.debug ?? !1,
+    language: t.language ?? "en",
+    user: t.user ?? {},
+    soundEffectFiles: Object.assign({}, pe, t.soundEffectFiles),
+    theme: Object.assign({}, Ee, t.theme),
+    settings: Object.assign({}, te, t.settings),
+    assets: {
+      organizationLogo: ((o = t.assets) == null ? void 0 : o.organizationLogo) ?? ""
+    }
+  }, r = `${s.token}:settings`, { getSettings: a, updateSettings: l } = be(s.settings, e, r);
+  return {
+    config: s,
+    updateSettings: l,
+    getConfig: () => ({
+      ...s,
+      settings: a()
+    }),
+    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 we = /\{[^{}]+\}/g, Pe = () => {
+  var t, e;
+  return typeof process == "object" && Number.parseInt((e = (t = process == null ? void 0 : process.versions) == null ? void 0 : t.node) == null ? void 0 : e.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function Te() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function Ae(t) {
+  let {
+    baseUrl: e = "",
+    Request: s = globalThis.Request,
+    fetch: r = globalThis.fetch,
+    querySerializer: a,
+    bodySerializer: l,
+    headers: c,
+    requestInitExt: n = void 0,
+    ...d
+  } = { ...t };
+  n = Pe() ? n : void 0, e = ee(e);
+  const i = [];
+  async function o(m, f) {
+    const {
+      baseUrl: b,
+      fetch: w = r,
+      Request: R = s,
+      headers: I,
+      params: p = {},
+      parseAs: C = "json",
+      querySerializer: v,
+      bodySerializer: O = l ?? Oe,
+      body: D,
+      ...L
+    } = f || {};
+    b && (e = ee(b));
+    let u = typeof a == "function" ? a : Z(a);
+    v && (u = typeof v == "function" ? v : Z({
+      ...typeof a == "object" ? a : {},
+      ...v
+    }));
+    const g = D === void 0 ? void 0 : O(D), h = (
+      // with no body, we should not to set Content-Type
+      g === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      g instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      }
+    ), q = {
+      redirect: "follow",
+      ...d,
+      ...L,
+      body: g,
+      headers: Ce(h, c, I, p.header)
+    };
+    let $, z, x = new s(Re(m, { baseUrl: e, params: p, querySerializer: u }), q);
+    for (const P in L)
+      P in x || (x[P] = L[P]);
+    if (i.length) {
+      $ = Te(), z = Object.freeze({
+        baseUrl: e,
+        fetch: w,
+        parseAs: C,
+        querySerializer: u,
+        bodySerializer: O
+      });
+      for (const P of i)
+        if (P && typeof P == "object" && typeof P.onRequest == "function") {
+          const T = await P.onRequest({
+            request: x,
+            schemaPath: m,
+            params: p,
+            options: z,
+            id: $
+          });
+          if (T) {
+            if (!(T instanceof s))
+              throw new Error("onRequest: must return new Request() when modifying the request");
+            x = T;
+          }
+        }
+    }
+    let E;
+    try {
+      E = await w(x, n);
+    } catch (P) {
+      let T = P;
+      if (i.length)
+        for (let M = i.length - 1; M >= 0; M--) {
+          const H = i[M];
+          if (H && typeof H == "object" && typeof H.onError == "function") {
+            const j = await H.onError({
+              request: x,
+              error: T,
+              schemaPath: m,
+              params: p,
+              options: z,
+              id: $
+            });
+            if (j) {
+              if (j instanceof Response) {
+                T = void 0, E = j;
+                break;
+              }
+              if (j instanceof Error) {
+                T = j;
+                continue;
+              }
+              throw new Error("onError: must return new Response() or instance of Error");
+            }
+          }
+        }
+      if (T)
+        throw T;
+    }
+    if (i.length)
+      for (let P = i.length - 1; P >= 0; P--) {
+        const T = i[P];
+        if (T && typeof T == "object" && typeof T.onResponse == "function") {
+          const M = await T.onResponse({
+            request: x,
+            response: E,
+            schemaPath: m,
+            params: p,
+            options: z,
+            id: $
+          });
+          if (M) {
+            if (!(M instanceof Response))
+              throw new Error("onResponse: must return new Response() when modifying the response");
+            E = M;
+          }
+        }
+      }
+    if (E.status === 204 || E.headers.get("Content-Length") === "0")
+      return E.ok ? { data: void 0, response: E } : { error: void 0, response: E };
+    if (E.ok)
+      return C === "stream" ? { data: E.body, response: E } : { data: await E[C](), response: E };
+    let K = await E.text();
+    try {
+      K = JSON.parse(K);
+    } catch {
+    }
+    return { error: K, response: E };
+  }
+  return {
+    request(m, f, b) {
+      return o(f, { ...b, method: m.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(m, f) {
+      return o(m, { ...f, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(m, f) {
+      return o(m, { ...f, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(m, f) {
+      return o(m, { ...f, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(m, f) {
+      return o(m, { ...f, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(m, f) {
+      return o(m, { ...f, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(m, f) {
+      return o(m, { ...f, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(m, f) {
+      return o(m, { ...f, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(m, f) {
+      return o(m, { ...f, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...m) {
+      for (const f of m)
+        if (f) {
+          if (typeof f != "object" || !("onRequest" in f || "onResponse" in f || "onError" in f))
+            throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+          i.push(f);
+        }
+    },
+    /** Unregister middleware */
+    eject(...m) {
+      for (const f of m) {
+        const b = i.indexOf(f);
+        b !== -1 && i.splice(b, 1);
+      }
+    }
+  };
+}
+function W(t, e, s) {
+  if (e == null)
+    return "";
+  if (typeof e == "object")
+    throw new Error(
+      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
+    );
+  return `${t}=${(s == null ? void 0 : s.allowReserved) === !0 ? e : encodeURIComponent(e)}`;
+}
+function se(t, e, s) {
+  if (!e || typeof e != "object")
+    return "";
+  const r = [], a = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[s.style] || "&";
+  if (s.style !== "deepObject" && s.explode === !1) {
+    for (const n in e)
+      r.push(n, s.allowReserved === !0 ? e[n] : encodeURIComponent(e[n]));
+    const c = r.join(",");
+    switch (s.style) {
+      case "form":
+        return `${t}=${c}`;
+      case "label":
+        return `.${c}`;
+      case "matrix":
+        return `;${t}=${c}`;
+      default:
+        return c;
+    }
+  }
+  for (const c in e) {
+    const n = s.style === "deepObject" ? `${t}[${c}]` : c;
+    r.push(W(n, e[c], s));
+  }
+  const l = r.join(a);
+  return s.style === "label" || s.style === "matrix" ? `${a}${l}` : l;
+}
+function re(t, e, s) {
+  if (!Array.isArray(e))
+    return "";
+  if (s.explode === !1) {
+    const l = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[s.style] || ",", c = (s.allowReserved === !0 ? e : e.map((n) => encodeURIComponent(n))).join(l);
+    switch (s.style) {
+      case "simple":
+        return c;
+      case "label":
+        return `.${c}`;
+      case "matrix":
+        return `;${t}=${c}`;
+      default:
+        return `${t}=${c}`;
+    }
+  }
+  const r = { simple: ",", label: ".", matrix: ";" }[s.style] || "&", a = [];
+  for (const l of e)
+    s.style === "simple" || s.style === "label" ? a.push(s.allowReserved === !0 ? l : encodeURIComponent(l)) : a.push(W(t, l, s));
+  return s.style === "label" || s.style === "matrix" ? `${r}${a.join(r)}` : a.join(r);
+}
+function Z(t) {
+  return function(s) {
+    const r = [];
+    if (s && typeof s == "object")
+      for (const a in s) {
+        const l = s[a];
+        if (l != null) {
+          if (Array.isArray(l)) {
+            if (l.length === 0)
+              continue;
+            r.push(
+              re(a, l, {
+                style: "form",
+                explode: !0,
+                ...t == null ? void 0 : t.array,
+                allowReserved: (t == null ? void 0 : t.allowReserved) || !1
+              })
+            );
+            continue;
+          }
+          if (typeof l == "object") {
+            r.push(
+              se(a, l, {
+                style: "deepObject",
+                explode: !0,
+                ...t == null ? void 0 : t.object,
+                allowReserved: (t == null ? void 0 : t.allowReserved) || !1
+              })
+            );
+            continue;
+          }
+          r.push(W(a, l, t));
+        }
+      }
+    return r.join("&");
+  };
+}
+function Ie(t, e) {
+  let s = t;
+  for (const r of t.match(we) ?? []) {
+    let a = r.substring(1, r.length - 1), l = !1, c = "simple";
+    if (a.endsWith("*") && (l = !0, a = a.substring(0, a.length - 1)), a.startsWith(".") ? (c = "label", a = a.substring(1)) : a.startsWith(";") && (c = "matrix", a = a.substring(1)), !e || e[a] === void 0 || e[a] === null)
+      continue;
+    const n = e[a];
+    if (Array.isArray(n)) {
+      s = s.replace(r, re(a, n, { style: c, explode: l }));
+      continue;
+    }
+    if (typeof n == "object") {
+      s = s.replace(r, se(a, n, { style: c, explode: l }));
+      continue;
+    }
+    if (c === "matrix") {
+      s = s.replace(r, `;${W(a, n)}`);
+      continue;
+    }
+    s = s.replace(r, c === "label" ? `.${encodeURIComponent(n)}` : encodeURIComponent(n));
+  }
+  return s;
+}
+function Oe(t) {
+  return t instanceof FormData ? t : JSON.stringify(t);
+}
+function Re(t, e) {
+  var a;
+  let s = `${e.baseUrl}${t}`;
+  (a = e.params) != null && a.path && (s = Ie(s, e.params.path));
+  let r = e.querySerializer(e.params.query ?? {});
+  return r.startsWith("?") && (r = r.substring(1)), r && (s += `?${r}`), s;
+}
+function Ce(...t) {
+  const e = new Headers();
+  for (const s of t) {
+    if (!s || typeof s != "object")
+      continue;
+    const r = s instanceof Headers ? s.entries() : Object.entries(s);
+    for (const [a, l] of r)
+      if (l === null)
+        e.delete(a);
+      else if (Array.isArray(l))
+        for (const c of l)
+          e.append(a, c);
+      else l !== void 0 && e.set(a, l);
+  }
+  return e;
+}
+function ee(t) {
+  return t.endsWith("/") ? t.substring(0, t.length - 1) : t;
+}
+const Le = (t) => {
+  console.log(t.error);
+}, ve = (t) => {
+  const e = Ae({
+    baseUrl: t.baseUrl
+  }), s = {
+    onRequest: t.onRequest,
+    onResponse: t.onResponse,
+    onError: t.onError || Le
+  };
+  return e.use(s), e;
+};
+var A;
+class Ge {
+  constructor(e) {
+    G(this, A);
+    S(this, "createClient", (e) => {
+      const s = {
+        claim: "",
+        value: ""
+      };
+      return e != null && e.email ? (s.claim = "email", s.value = e.email) : e != null && e.phone && (s.claim = "phone", s.value = e.phone), ve({
+        baseUrl: this.options.config.apiUrl,
+        onRequest: ({ request: r }) => {
+          r.headers.set("X-Bot-Token", this.options.config.token), r.headers.set(
+            "X-Consumer-Id",
+            `${s.claim}:${s.value}`
+          ), r.headers.set("Content-Type", "application/json"), r.headers.set("Accept", "application/json"), this.options.config.contactToken && r.headers.set(
+            "Authorization",
+            `Bearer ${this.options.config.contactToken}`
+          );
+        }
+      });
+    });
+    S(this, "setUser", (e) => {
+      F(this, A, this.createClient(e));
+    });
+    S(this, "me", async () => await y(this, A).GET("/backend/widget/v2/me"));
+    S(this, "widgetPrelude", async () => await y(this, A).GET("/backend/widget/v2/prelude", {
+      params: { header: { "X-Bot-Token": this.options.config.token } }
+    }));
+    S(this, "handleMessage", async (e, s) => await y(this, A).POST("/backend/widget/v2/chat/send", {
+      body: e,
+      signal: s
+    }));
+    S(this, "getSessionHistory", async (e, s) => {
+      const r = s ? { lastMessageTimestamp: s } : void 0;
+      return await y(this, A).GET(
+        "/backend/widget/v2/session/history/{sessionId}",
+        { params: { path: { sessionId: e }, query: r } }
+      );
+    });
+    S(this, "createContact", async (e) => await y(this, A).POST("/backend/widget/v2/me/create", {
+      params: { header: { "x-bot-token": this.options.config.token } },
+      body: e
+    }));
+    S(this, "createSession", async () => await y(this, A).POST("/backend/widget/v2/create-session"));
+    S(this, "getSession", async (e) => await y(this, A).GET("/backend/widget/v2/session/{sessionId}", {
+      params: { path: { sessionId: e } }
+    }));
+    S(this, "uploadFile", async ({
+      file: e,
+      abortSignal: s
+    }) => {
+      const r = new FormData();
+      return r.append("file", e.file), await y(this, A).POST("/backend/widget/v2/upload", {
+        params: { query: { fileId: e.id, sessionId: "" } },
+        body: r,
+        signal: s,
+        headers: {
+          "Content-Type": "multipart/form-data"
+        }
+      });
+    });
+    S(this, "vote", async (e) => await y(this, A).POST("/backend/widget/v2/chat/vote", { body: e }));
+    this.options = e, F(this, A, this.createClient(e.config.user));
+  }
+}
+A = new WeakMap();
+export {
+  Ge as A,
+  xe as C,
+  je as E,
+  ke as F,
+  ue as L,
+  N as O,
+  X as P,
+  le as S,
+  Ne as T,
+  ge as a,
+  He as b,
+  ze as c,
+  $e as d,
+  Me as e,
+  Fe as f,
+  ce as g,
+  qe as h,
+  U as i,
+  fe as j,
+  de as k,
+  Y as s
+};
+//# sourceMappingURL=api-Cez5T-se.js.map