@ant-design-x-vue/x-sdk 0.0.0-stage → 2.0.0

package/dist/index.mjs

@@ -0,0 +1,775 @@
+var ee = Object.defineProperty;
+var te = (r, e, t) => e in r ? ee(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var a = (r, e, t) => te(r, typeof e != "symbol" ? e + "" : e, t);
+import { shallowRef as I, watch as se, ref as N, computed as B, onBeforeUnmount as re } from "vue";
+const b = {
+  _chatMessagesStores: /* @__PURE__ */ new Map(),
+  get: (r) => b._chatMessagesStores.get(r),
+  set: (r, e) => {
+    b._chatMessagesStores.set(r, e);
+  },
+  delete: (r) => {
+    b._chatMessagesStores.delete(r);
+  },
+  getMessages: (r) => {
+    const e = b._chatMessagesStores.get(r);
+    return e == null ? void 0 : e.getMessages();
+  }
+};
+class ne {
+  constructor(e, t) {
+    a(this, "messages", []);
+    a(this, "listeners", []);
+    a(this, "conversationKey");
+    a(this, "setMessages", (e) => {
+      let t;
+      return typeof e == "function" ? t = e(this.messages) : t = e, this.messages = [...t], this.emitListeners(), !0;
+    });
+    a(this, "getMessages", () => this.messages);
+    a(this, "getMessage", (e) => this.messages.find((t) => t.id === e));
+    a(this, "addMessage", (e) => this.getMessage(e.id) ? !1 : (this.setMessages([...this.messages, e]), !0));
+    a(this, "setMessage", (e, t) => {
+      const s = this.getMessage(e);
+      if (s) {
+        const n = typeof t == "function" ? t(s) : t;
+        return Object.assign(s, n), this.setMessages([...this.messages]), !0;
+      }
+      return !1;
+    });
+    a(this, "removeMessage", (e) => {
+      const t = this.messages.findIndex((s) => s.id === e);
+      return t !== -1 ? (this.messages.splice(t, 1), this.setMessages([...this.messages]), !0) : !1;
+    });
+    a(this, "getSnapshot", () => this.messages);
+    a(this, "subscribe", (e) => (this.listeners.push(e), () => {
+      this.listeners = this.listeners.filter((t) => t !== e);
+    }));
+    this.setMessages(e), t != null && (this.conversationKey = t, b.set(this.conversationKey, this));
+  }
+  emitListeners() {
+    this.listeners.forEach((e) => {
+      e();
+    });
+  }
+}
+function oe(r, e) {
+  const t = e && typeof e == "object" && "value" in e ? e : I(e), s = (u) => {
+    if (u !== void 0 && b.get(u))
+      return b.get(u);
+    const d = typeof r == "function" ? r() : r;
+    return new ne(d || [], u);
+  }, n = I(s(t.value)), o = I(n.value.getMessages());
+  let i = null;
+  const l = () => {
+    i && i(), o.value = n.value.getMessages(), i = n.value.subscribe(() => {
+      o.value = [...n.value.getMessages()];
+    });
+  };
+  return l(), se(
+    () => t.value,
+    () => {
+      n.value = s(t.value), l();
+    }
+  ), {
+    messages: o,
+    addMessage: (u) => n.value.addMessage(u),
+    removeMessage: (u) => n.value.removeMessage(u),
+    setMessage: (u, d) => n.value.setMessage(u, d),
+    getMessage: (u) => n.value.getMessage(u),
+    setMessages: (u) => n.value.setMessages(u),
+    getMessages: () => n.value.getMessages()
+  };
+}
+function ie(r) {
+  return Array.isArray(r) ? r : [r];
+}
+const U = /* @__PURE__ */ new Map();
+function Ce(r) {
+  const {
+    defaultMessages: e,
+    requestFallback: t,
+    requestPlaceholder: s,
+    parser: n,
+    provider: o,
+    conversationKey: i
+  } = r, l = N(0), u = I(void 0), d = N(!1), f = i && typeof i == "object" && "value" in i ? i : I(i), {
+    messages: m,
+    setMessages: v,
+    getMessages: g,
+    setMessage: q
+  } = oe(
+    () => (e || []).map((h, c) => ({
+      id: `default_${c}`,
+      status: "local",
+      ...h
+    })),
+    f
+  ), T = (h, c, R) => {
+    const _ = {
+      id: `msg_${l.value}`,
+      message: h,
+      status: c
+    };
+    return R && (_.extraInfo = R), l.value += 1, _;
+  }, C = B(() => {
+    const h = [];
+    return m.value.forEach((c) => {
+      const R = n ? n(c.message) : c.message, _ = ie(R);
+      _.forEach((x, j) => {
+        let K = c.id;
+        _.length > 1 && (K = `${K}_${j}`), h.push({
+          id: K,
+          message: x,
+          status: c.status
+        });
+      });
+    }), h;
+  }), w = (h) => h.filter((c) => c.status !== "loading").map((c) => c.message);
+  o && (o.injectGetMessages(() => w(g())), u.value = o.request);
+  const Q = () => w(g()), X = (h, c) => {
+    if (!o) return;
+    const { updatingId: R, reload: _ } = c || {};
+    let x = null;
+    const j = o.transformLocalMessage(h), K = (Array.isArray(j) ? j : [j]).map(
+      (M) => T(M, "local", c == null ? void 0 : c.extraInfo)
+    );
+    _ ? (x = R, v((M) => {
+      const p = [...M];
+      if (s) {
+        let y;
+        typeof s == "function" ? y = s(
+          h,
+          {
+            messages: w(p)
+          }
+        ) : y = s, p.forEach((S) => {
+          S.id === R && (S.status = "loading", S.message = y, c != null && c.extraInfo && (S.extraInfo = c.extraInfo));
+        });
+      }
+      return p;
+    })) : v((M) => {
+      let p = [...M, ...K];
+      if (s) {
+        let y;
+        typeof s == "function" ? y = s(
+          h,
+          {
+            messages: w(p)
+          }
+        ) : y = s;
+        const S = T(y, "loading");
+        x = S.id, p = [...p, S];
+      }
+      return p;
+    });
+    let H = null;
+    const P = (M, p, y, S) => {
+      let E = g().find((A) => A.id === H);
+      if (E)
+        v((A) => A.map((O) => {
+          if (O.id === H) {
+            const $ = o.transformMessage({
+              originMessage: O.message,
+              chunk: p,
+              chunks: y,
+              status: M,
+              responseHeaders: S
+            });
+            return {
+              ...O,
+              message: $,
+              status: M
+            };
+          }
+          return O;
+        }));
+      else if (_ && R)
+        E = g().find((A) => A.id === R), E && (E.status = M, E.message = o.transformMessage({ chunk: p, status: M, chunks: y, responseHeaders: S }), v((A) => [...A]), H = E.id);
+      else {
+        const A = o.transformMessage({
+          chunk: p,
+          status: M,
+          chunks: y,
+          responseHeaders: S
+        }), O = T(A, M);
+        v(($) => [...$.filter((k) => k.id !== x), O]), H = O.id, E = O;
+      }
+      return E;
+    };
+    o.injectRequest({
+      onUpdate: (M, p) => {
+        P("updating", M, [], p);
+      },
+      onSuccess: (M, p) => {
+        d.value = !1, f.value !== void 0 && f.value !== null && U.delete(f.value), P("success", void 0, M, p);
+      },
+      onError: async (M) => {
+        if (d.value = !1, f.value !== void 0 && f.value !== null && U.delete(f.value), t) {
+          let p;
+          if (typeof t == "function") {
+            const y = Q(), S = g().find(
+              (E) => E.id === x || E.id === H
+            );
+            p = await t(h, {
+              error: M,
+              messageInfo: S,
+              messages: y
+            });
+          } else
+            p = t;
+          v((y) => [
+            ...y.filter(
+              (S) => S.id !== x && S.id !== H
+            ),
+            T(p, M.name === "AbortError" ? "abort" : "error")
+          ]);
+        } else
+          v((p) => p.map((y) => y.id === x || y.id === H ? {
+            ...y,
+            status: M.name === "AbortError" ? "abort" : "error"
+          } : y));
+      }
+    }), d.value = !0, f.value !== void 0 && f.value !== null && U.set(f.value, !0), o.request.run(o.transformParams(h, o.request.options));
+  }, V = (h, c) => {
+    if (!o)
+      throw new Error("provider is required");
+    X(h, c);
+  }, Y = (h, c, R) => {
+    if (!o)
+      throw new Error("provider is required");
+    if (!h || !g().find((_) => _.id === h))
+      throw new Error(`message [${h}] is not found`);
+    X(c, {
+      updatingId: h,
+      reload: !0,
+      extraInfo: R == null ? void 0 : R.extraInfo
+    });
+  }, Z = B(() => {
+    const h = f.value;
+    return h != null ? U.get(h) || !1 : d.value;
+  });
+  return {
+    onRequest: V,
+    messages: m,
+    parsedMessages: C,
+    setMessages: v,
+    setMessage: q,
+    abort: () => {
+      var h;
+      if (!o)
+        throw new Error("provider is required");
+      (h = u.value) == null || h.abort();
+    },
+    isRequesting: Z,
+    onReload: Y
+  };
+}
+class D {
+  constructor(e) {
+    a(this, "_request");
+    a(this, "_getMessagesFn");
+    a(this, "_originalCallbacks");
+    var s;
+    const t = typeof e.request == "function" ? e.request() : e.request;
+    if (!t.manual)
+      throw new Error("request must be manual");
+    this._request = t, this._originalCallbacks = (s = this._request.options) == null ? void 0 : s.callbacks;
+  }
+  get request() {
+    return this._request;
+  }
+  getMessages() {
+    return this == null ? void 0 : this._getMessagesFn();
+  }
+  injectGetMessages(e) {
+    this._getMessagesFn = e;
+  }
+  injectRequest({
+    onUpdate: e,
+    onSuccess: t,
+    onError: s
+  }) {
+    var l, u, d;
+    const n = (l = this._originalCallbacks) == null ? void 0 : l.onUpdate, o = (u = this._originalCallbacks) == null ? void 0 : u.onSuccess, i = (d = this._originalCallbacks) == null ? void 0 : d.onError;
+    this._request.options.callbacks = {
+      onUpdate: (f, m) => {
+        e(f, m), n && n(f, m);
+      },
+      onSuccess: (f, m) => {
+        t(f, m), o && o(f, m);
+      },
+      onError: (f) => {
+        s(f), i && i(f);
+      }
+    };
+  }
+}
+class Re extends D {
+  transformParams(e, t) {
+    return {
+      ...(t == null ? void 0 : t.params) || {},
+      ...e,
+      messages: this.getMessages()
+    };
+  }
+  transformLocalMessage(e) {
+    return (e == null ? void 0 : e.messages) || [];
+  }
+  transformMessage(e) {
+    var v, g, q, T;
+    const { originMessage: t, chunk: s, chunks: n, responseHeaders: o } = e;
+    let i = "", l = "", u = "assistant";
+    try {
+      let C;
+      (v = o.get("content-type")) != null && v.includes("text/event-stream") ? s && ((g = s.data) == null ? void 0 : g.trim()) !== "[DONE]" && (C = JSON.parse(s.data)) : C = s || n[0], C && ((q = C == null ? void 0 : C.choices) == null || q.forEach((w) => {
+        w != null && w.delta ? (l = w.delta.reasoning_content || "", i += w.delta.content || "", u = w.delta.role) : w != null && w.message && (l = w.message.reasoning_content || "", i += w.message.content || "", u = w.message.role);
+      }));
+    } catch (C) {
+      console.error("transformMessage error", C);
+    }
+    let d = "";
+    const f = t;
+    let m = typeof (f == null ? void 0 : f.content) == "string" ? f == null ? void 0 : f.content : ((T = f == null ? void 0 : f.content) == null ? void 0 : T.text) || "";
+    return !m && l ? d = `<think>${l}` : m.includes("<think>") && !m.includes("</think>") && i ? (m = m.replace("<think>", '<think status="done">'), d = `${m}</think>${i}`) : d = `${m || ""}${l}${i}`, {
+      content: d,
+      role: u || "assistant"
+    };
+  }
+}
+class Te extends D {
+  transformParams(e, t) {
+    if (typeof e != "object")
+      throw new Error("requestParams must be an object");
+    return {
+      ...(t == null ? void 0 : t.params) || {},
+      ...e || {}
+    };
+  }
+  transformLocalMessage(e) {
+    return e;
+  }
+  transformMessage(e) {
+    const { chunk: t, chunks: s, originMessage: n } = e;
+    if (t)
+      return t;
+    if (Array.isArray(s)) {
+      const o = (s == null ? void 0 : s.length) > 0 ? s == null ? void 0 : s[(s == null ? void 0 : s.length) - 1] : void 0;
+      return n || o;
+    }
+    return s;
+  }
+}
+class ae extends D {
+  transformParams(e, t) {
+    return {
+      ...(t == null ? void 0 : t.params) || {},
+      ...e,
+      messages: this.getMessages()
+    };
+  }
+  transformLocalMessage(e) {
+    return (e == null ? void 0 : e.messages) || [];
+  }
+  transformMessage(e) {
+    var d, f, m;
+    const { originMessage: t, chunk: s, chunks: n, responseHeaders: o } = e;
+    let i = "", l = "assistant";
+    try {
+      let v;
+      (d = o.get("content-type")) != null && d.includes("text/event-stream") ? s && ((f = s.data) == null ? void 0 : f.trim()) !== "[DONE]" && (v = JSON.parse(s.data)) : v = s || n[0], v && ((m = v == null ? void 0 : v.choices) == null || m.forEach((g) => {
+        g != null && g.delta ? (i += g.delta.content || "", l = g.delta.role || "assistant") : g != null && g.message && (i += g.message.content || "", l = g.message.role || "assistant");
+      }));
+    } catch (v) {
+      console.error("transformMessage error", v);
+    }
+    return {
+      content: `${(t == null ? void 0 : t.content) || ""}${i || ""}`,
+      role: l
+    };
+  }
+}
+const ue = `
+
+`, fe = `
+`, G = ":", F = (r) => (r ?? "").trim() !== "";
+function le() {
+  let r = "";
+  return new TransformStream({
+    transform(e, t) {
+      r += e;
+      const s = r.split(ue);
+      s.slice(0, -1).forEach((n) => {
+        F(n) && t.enqueue(n);
+      }), r = s[s.length - 1];
+    },
+    flush(e) {
+      F(r) && e.enqueue(r);
+    }
+  });
+}
+function ge() {
+  return new TransformStream({
+    transform(r, e) {
+      const s = r.split(fe).reduce((n, o) => {
+        const i = o.indexOf(G);
+        if (i === -1)
+          throw new Error(
+            `The key-value separator "${G}" is not found in the sse line chunk!`
+          );
+        const l = o.slice(0, i);
+        if (!F(l)) return n;
+        const u = o.slice(i + 1);
+        return { ...n, [l]: u };
+      }, {});
+      Object.keys(s).length !== 0 && e.enqueue(s);
+    }
+  });
+}
+function J(r) {
+  const { readableStream: e, transformStream: t } = r;
+  if (!(e instanceof ReadableStream))
+    throw new Error("The options.readableStream must be an instance of ReadableStream.");
+  const s = new TextDecoderStream(), n = t ? e.pipeThrough(s).pipeThrough(t) : e.pipeThrough(s).pipeThrough(le()).pipeThrough(ge());
+  return n[Symbol.asyncIterator] = async function* () {
+    const o = this.getReader();
+    for (; ; ) {
+      const { done: i, value: l } = await o.read();
+      if (i) break;
+      l && (yield l);
+    }
+  }, n;
+}
+const de = async (r, e) => {
+  const { fetch: t = globalThis.fetch, middlewares: s = {}, ...n } = e;
+  if (typeof t != "function")
+    throw new Error("The options.fetch must be a typeof fetch function!");
+  let o = [
+    r,
+    n
+  ];
+  typeof s.onRequest == "function" && (o = await s.onRequest(...o));
+  let i = await t(...o);
+  if (typeof s.onResponse == "function") {
+    const l = await s.onResponse(i);
+    if (!(l instanceof Response))
+      throw new Error("The options.onResponse must return a Response instance!");
+    i = l;
+  }
+  if (!i.ok)
+    throw new Error(`Fetch failed with status ${i.status}`);
+  if (!i.body)
+    throw new Error("The response body is empty.");
+  return i;
+}, z = {
+  manual: !1,
+  headers: {
+    "Content-Type": "application/json"
+  }
+};
+function Ee(r) {
+  Object.assign(z, r);
+}
+class he {
+  constructor(e, t) {
+    a(this, "baseURL");
+    a(this, "options");
+    if (!e || typeof e != "string") throw new Error("The baseURL is not valid!");
+    this.baseURL = e, this.options = t || {};
+  }
+}
+class me extends he {
+  constructor(t, s) {
+    super(t, s);
+    a(this, "_asyncHandler");
+    a(this, "timeoutHandler", 0);
+    a(this, "_isTimeout", !1);
+    a(this, "streamTimeoutHandler", 0);
+    a(this, "_isStreamTimeout", !1);
+    a(this, "abortController");
+    a(this, "_isRequesting", !1);
+    a(this, "_manual", !1);
+    a(this, "customResponseHandler", async (t, s, n, o) => {
+      const i = J({
+        readableStream: t.body,
+        transformStream: n
+      });
+      await this.processStream(i, t, s, o);
+    });
+    a(this, "sseResponseHandler", async (t, s, n) => {
+      const o = J({
+        readableStream: t.body
+      });
+      await this.processStream(o, t, s, n);
+    });
+    a(this, "jsonResponseHandler", async (t, s) => {
+      var o, i, l;
+      const n = await t.json();
+      if ((n == null ? void 0 : n.success) === !1) {
+        const u = n, d = new Error(u.message || "System error");
+        d.name = u.name || "SystemError", (o = s == null ? void 0 : s.onError) == null || o.call(s, d);
+      } else
+        (i = s == null ? void 0 : s.onUpdate) == null || i.call(s, n, t.headers), this.finishRequest(), (l = s == null ? void 0 : s.onSuccess) == null || l.call(s, [n], t.headers);
+    });
+    this._manual = (s == null ? void 0 : s.manual) || !1, this.manual || this.init();
+  }
+  get asyncHandler() {
+    return this._asyncHandler;
+  }
+  get isTimeout() {
+    return this._isTimeout;
+  }
+  set isTimeout(t) {
+    this._isTimeout = t;
+  }
+  get isStreamTimeout() {
+    return this._isStreamTimeout;
+  }
+  set isStreamTimeout(t) {
+    this._isStreamTimeout = t;
+  }
+  get isRequesting() {
+    return this._isRequesting;
+  }
+  get manual() {
+    return this._manual;
+  }
+  run(t) {
+    this.manual ? this.init(t) : console.warn("The request is not manual, so it cannot be run!");
+  }
+  abort() {
+    var t;
+    clearTimeout(this.timeoutHandler), clearTimeout(this.streamTimeoutHandler), (t = this.abortController) == null || t.abort();
+  }
+  init(t) {
+    this.abortController = new AbortController();
+    const {
+      callbacks: s,
+      params: n,
+      headers: o = {},
+      transformStream: i,
+      fetch: l,
+      timeout: u,
+      streamTimeout: d,
+      middlewares: f,
+      ...m
+    } = this.options, v = {
+      ...m,
+      method: m.method || "POST",
+      body: m.body ?? JSON.stringify({
+        ...n,
+        ...t || {}
+      }),
+      params: {
+        ...n,
+        ...t
+      },
+      headers: Object.assign({}, z.headers || {}, o),
+      signal: this.abortController.signal,
+      middlewares: f
+    };
+    u && u > 0 && (this.timeoutHandler = setTimeout(() => {
+      var g;
+      this.isTimeout = !0, this.finishRequest(), (g = s == null ? void 0 : s.onError) == null || g.call(s, new Error("TimeoutError"));
+    }, u)), this.startRequest(), this._asyncHandler = de(this.baseURL, {
+      fetch: l,
+      ...v
+    }).then(async (g) => {
+      if (clearTimeout(this.timeoutHandler), this.isTimeout) return;
+      if (i) {
+        let C = i;
+        typeof i == "function" && (C = i(this.baseURL, g.headers)), await this.customResponseHandler(g, s, C, d);
+        return;
+      }
+      const q = g.headers.get("content-type") || "";
+      switch (q.split(";")[0].trim()) {
+        case "text/event-stream":
+          await this.sseResponseHandler(g, s, d);
+          break;
+        case "application/json":
+          await this.jsonResponseHandler(g, s);
+          break;
+        default:
+          throw new Error(`The response content-type: ${q} is not support!`);
+      }
+    }).catch((g) => {
+      var T;
+      clearTimeout(this.timeoutHandler), this.finishRequest();
+      const q = g instanceof Error || typeof DOMException < "u" && g instanceof DOMException ? g : new Error("Unknown error!");
+      (T = s == null ? void 0 : s.onError) == null || T.call(s, q);
+    });
+  }
+  startRequest() {
+    this._isRequesting = !0;
+  }
+  finishRequest() {
+    this._isRequesting = !1;
+  }
+  async processStream(t, s, n, o) {
+    var d, f;
+    const i = [], l = t[Symbol.asyncIterator]();
+    let u;
+    do
+      if (o && (this.streamTimeoutHandler = setTimeout(() => {
+        var m;
+        this.isStreamTimeout = !0, this.finishRequest(), (m = n == null ? void 0 : n.onError) == null || m.call(n, new Error("StreamTimeoutError"));
+      }, o)), u = await l.next(), u.value !== void 0 && (i.push(u.value), (d = n == null ? void 0 : n.onUpdate) == null || d.call(n, u.value, s.headers)), clearTimeout(this.streamTimeoutHandler), this.isStreamTimeout)
+        break;
+    while (!u.done);
+    if (o && (clearTimeout(this.streamTimeoutHandler), this.isStreamTimeout)) {
+      this.finishRequest();
+      return;
+    }
+    this.finishRequest(), (f = n == null ? void 0 : n.onSuccess) == null || f.call(n, i, s.headers);
+  }
+}
+function W(r, e) {
+  return new me(r, e);
+}
+function ce(r) {
+  const e = r.dangerouslyApiKey || r.key;
+  if (e)
+    return /^(Bearer |Basic |Tbox-)/.test(e) ? e : `Bearer ${e}`;
+}
+function _e(r) {
+  const e = ce(r);
+  return new ae({
+    request: W(r.baseURL, {
+      manual: !0,
+      params: {
+        ...r.model ? { model: r.model } : {},
+        stream: !0
+      },
+      headers: e ? { Authorization: e } : {},
+      // `fetch` is invariant in XRequest's generic options; the preset only needs the body.
+      ...r.fetch ? { fetch: r.fetch } : {}
+    })
+  });
+}
+const L = {
+  _allConversationStores: /* @__PURE__ */ new Map(),
+  set(r, e) {
+    L._allConversationStores.set(r, e);
+  },
+  delete(r) {
+    L._allConversationStores.delete(r);
+  },
+  getConversation(r) {
+    for (const e of Array.from(
+      L._allConversationStores.values()
+    )) {
+      const t = e.getConversation(r);
+      if (t) return t;
+    }
+  }
+};
+class ve {
+  constructor(e, t) {
+    a(this, "conversations", []);
+    a(this, "listeners", []);
+    a(this, "storeKey");
+    a(this, "activeConversationKey");
+    a(this, "setActiveConversationKey", (e) => (this.activeConversationKey = e, this.emitListeners(), !0));
+    a(this, "setConversations", (e) => (this.conversations = [...e], this.emitListeners(), !0));
+    a(this, "getConversation", (e) => this.conversations.find((t) => t.key === e));
+    a(this, "addConversation", (e, t) => this.getConversation(e.key) ? !1 : (this.setConversations(
+      t === "prepend" ? [e, ...this.conversations] : [...this.conversations, e]
+    ), !0));
+    a(this, "setConversation", (e, t) => {
+      const s = this.getConversation(e);
+      return s ? (Object.assign(s, t), this.setConversations([...this.conversations]), !0) : !1;
+    });
+    a(this, "removeConversation", (e) => {
+      const t = this.conversations.findIndex((s) => s.key === e);
+      return t !== -1 ? (this.conversations.splice(t, 1), this.setConversations([...this.conversations]), !0) : !1;
+    });
+    a(this, "getMessages", (e) => b.getMessages(e));
+    a(this, "getSnapshot", () => this.conversations);
+    a(this, "getActiveConversationKey", () => this.activeConversationKey);
+    a(this, "subscribe", (e) => (this.listeners.push(e), () => {
+      this.listeners = this.listeners.filter((t) => t !== e);
+    }));
+    a(this, "destroy", () => {
+      L.delete(this.storeKey);
+    });
+    this.conversations = [...e], this.storeKey = Math.random().toString(), L.set(this.storeKey, this), this.activeConversationKey = t;
+  }
+  emitListeners() {
+    for (const e of this.listeners) e();
+  }
+}
+function qe(r = {}) {
+  const e = new ve(
+    r.defaultConversations || [],
+    r.defaultActiveConversationKey || ""
+  ), t = I(e.getSnapshot()), s = I(e.getActiveConversationKey()), n = e.subscribe(() => {
+    t.value = [...e.getSnapshot()], s.value = e.getActiveConversationKey();
+  });
+  return re(() => {
+    n(), e.destroy();
+  }), {
+    conversations: t,
+    activeConversationKey: s,
+    setActiveConversationKey: e.setActiveConversationKey,
+    addConversation: e.addConversation,
+    removeConversation: e.removeConversation,
+    setConversation: e.setConversation,
+    getConversation: e.getConversation,
+    setConversations: e.setConversations,
+    getMessages: e.getMessages
+  };
+}
+class pe {
+  constructor(e, t) {
+    a(this, "baseURL");
+    a(this, "options");
+    if (!e || typeof e != "string")
+      throw new Error("The baseURL is not valid!");
+    this.baseURL = e, this.options = t;
+  }
+  /**
+   * Fetch the list of tools published by the MCP server.
+   */
+  async tools() {
+    return new Promise((e, t) => {
+      W(this.baseURL, {
+        ...this.options || {},
+        callbacks: {
+          onSuccess(s) {
+            e((s == null ? void 0 : s[0]) || []);
+          },
+          onError(s) {
+            t(s);
+          }
+        }
+      });
+    });
+  }
+}
+function Me(r, e) {
+  return new pe(r, e);
+}
+const Ae = Me, xe = "2.0.0";
+export {
+  D as AbstractChatProvider,
+  he as AbstractXRequestClass,
+  ne as ChatMessagesStore,
+  ve as ConversationStore,
+  Re as DeepSeekChatProvider,
+  Te as DefaultChatProvider,
+  ae as OpenAIChatProvider,
+  Me as XMCPClient,
+  pe as XMCPClientClass,
+  Ae as XMcpClient,
+  W as XRequest,
+  me as XRequestClass,
+  J as XStream,
+  b as chatMessagesStoreHelper,
+  L as conversationStoreHelper,
+  _e as createOpenAIChatProvider,
+  ce as resolvePresetApiKey,
+  Ee as setXRequestGlobalOptions,
+  oe as useChatStore,
+  Ce as useXChat,
+  qe as useXConversations,
+  xe as version
+};