ai 0.0.0-e27b4ed4-20240419203611

package/svelte/dist/index.mjs

@@ -0,0 +1,1528 @@
+// ../../node_modules/.pnpm/swrev@4.0.0/node_modules/swrev/dist/swrev.mjs
+var P = Object.defineProperty;
+var F = (r, e, t) => e in r ? P(r, e, { enumerable: true, configurable: true, writable: true, value: t }) : r[e] = t;
+var h = (r, e, t) => (F(r, typeof e != "symbol" ? e + "" : e, t), t);
+var I = class {
+  constructor() {
+    h(this, "listeners", /* @__PURE__ */ new Map());
+  }
+  /**
+   * Subscribes a given listener.
+   */
+  subscribe(e, t) {
+    this.listeners.has(e) || this.listeners.set(e, []), !this.listeners.get(e).includes(t) && this.listeners.get(e).push(t);
+  }
+  /**
+   * Unsubscribes the given listener.
+   */
+  unsubscribe(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).includes(t) && (this.listeners.get(e).splice(this.listeners.get(e).indexOf(t), 1), this.listeners.get(e).length === 0 && this.listeners.delete(e));
+  }
+  /**
+   * Emits an event to all active listeners.
+   */
+  emit(e, t) {
+    this.listeners.has(e) && this.listeners.get(e).forEach((s) => s(t));
+  }
+};
+var L = {
+  broadcast: false
+};
+var S = {
+  broadcast: false
+};
+var O = class {
+  /**
+   * Creates the cache item given the data and expiration at.
+   */
+  constructor({ data: e, expiresAt: t = null }) {
+    h(this, "data");
+    h(this, "expiresAt");
+    this.data = e, this.expiresAt = t;
+  }
+  /**
+   * Determines if the current cache item is still being resolved.
+   * This returns true if data is a promise, or false if type `D`.
+   */
+  isResolving() {
+    return this.data instanceof Promise;
+  }
+  /**
+   * Determines if the given cache item has expired.
+   */
+  hasExpired() {
+    return this.expiresAt === null || this.expiresAt < /* @__PURE__ */ new Date();
+  }
+  /**
+   * Set the expiration time of the given cache item relative to now.
+   */
+  expiresIn(e) {
+    return this.expiresAt = /* @__PURE__ */ new Date(), this.expiresAt.setMilliseconds(this.expiresAt.getMilliseconds() + e), this;
+  }
+};
+var q = class {
+  constructor() {
+    h(this, "elements", /* @__PURE__ */ new Map());
+    h(this, "event", new I());
+  }
+  /**
+   * Resolves the promise and replaces the Promise to the resolved data.
+   * It also broadcasts the value change if needed or deletes the key if
+   * the value resolves to undefined or null.
+   */
+  resolve(e, t) {
+    Promise.resolve(t.data).then((s) => {
+      if (s == null)
+        return this.remove(e);
+      t.data = s, this.broadcast(e, s);
+    });
+  }
+  /**
+   * Gets an element from the cache.
+   *
+   * It is assumed the item always exist when
+   * you get it. Use the has method to check
+   * for the existence of it.
+   */
+  get(e) {
+    return this.elements.get(e);
+  }
+  /**
+   * Sets an element to the cache.
+   */
+  set(e, t) {
+    this.elements.set(e, t), this.resolve(e, t);
+  }
+  /**
+   * Removes an key-value pair from the cache.
+   */
+  remove(e, t) {
+    const { broadcast: s } = { ...L, ...t };
+    s && this.broadcast(e, void 0), this.elements.delete(e);
+  }
+  /**
+   * Removes all the key-value pairs from the cache.
+   */
+  clear(e) {
+    const { broadcast: t } = { ...S, ...e };
+    if (t)
+      for (const s of this.elements.keys())
+        this.broadcast(s, void 0);
+    this.elements.clear();
+  }
+  /**
+   * Determines if the given key exists
+   * in the cache.
+   */
+  has(e) {
+    return this.elements.has(e);
+  }
+  /**
+   * Subscribes the callback to the given key.
+   */
+  subscribe(e, t) {
+    this.event.subscribe(e, t);
+  }
+  /**
+   * Unsubscribes to the given key events.
+   */
+  unsubscribe(e, t) {
+    this.event.unsubscribe(e, t);
+  }
+  /**
+   * Broadcasts a value change  on all subscribed instances.
+   */
+  broadcast(e, t) {
+    this.event.emit(e, t);
+  }
+};
+var x = {
+  cache: new q(),
+  errors: new I(),
+  fetcher: async (r) => {
+    const e = await fetch(r);
+    if (!e.ok)
+      throw Error("Not a 2XX response.");
+    return e.json();
+  },
+  fallbackData: void 0,
+  loadInitialCache: true,
+  revalidateOnStart: true,
+  dedupingInterval: 2e3,
+  revalidateOnFocus: true,
+  focusThrottleInterval: 5e3,
+  revalidateOnReconnect: true,
+  reconnectWhen: (r, { enabled: e }) => e && typeof window < "u" ? (window.addEventListener("online", r), () => window.removeEventListener("online", r)) : () => {
+  },
+  focusWhen: (r, { enabled: e, throttleInterval: t }) => {
+    if (e && typeof window < "u") {
+      let s = null;
+      const i = () => {
+        const a = Date.now();
+        (s === null || a - s > t) && (s = a, r());
+      };
+      return window.addEventListener("focus", i), () => window.removeEventListener("focus", i);
+    }
+    return () => {
+    };
+  },
+  revalidateFunction: void 0
+};
+var E = {
+  ...x,
+  force: false
+};
+var T = {
+  revalidate: true,
+  revalidateOptions: { ...E },
+  revalidateFunction: void 0
+};
+var X = {
+  broadcast: false
+};
+var H = class {
+  /**
+   * Creates a new instance of SWR.
+   */
+  constructor(e) {
+    h(this, "options");
+    this.options = { ...x, ...e };
+  }
+  /**
+   * Gets the cache of the SWR.
+   */
+  get cache() {
+    return this.options.cache;
+  }
+  /**
+   * Gets the cache of the SWR.
+   */
+  get errors() {
+    return this.options.errors;
+  }
+  /**
+   * Requests the data using the provided fetcher.
+   */
+  async requestData(e, t) {
+    return await Promise.resolve(t(e)).catch((s) => {
+      throw this.errors.emit(e, s), s;
+    });
+  }
+  /**
+   * Resolves the given to a SWRKey or undefined.
+   */
+  resolveKey(e) {
+    if (typeof e == "function")
+      try {
+        return e();
+      } catch (e2) {
+        return;
+      }
+    return e;
+  }
+  /**
+   * Clear the specified keys from the cache. If no keys
+   * are specified, it clears all the cache keys.
+   */
+  clear(e, t) {
+    const s = { ...X, ...t };
+    if (e == null)
+      return this.cache.clear(s);
+    if (!Array.isArray(e))
+      return this.cache.remove(e, s);
+    for (const i of e)
+      this.cache.remove(i, s);
+  }
+  /**
+   * Revalidates the key and mutates the cache if needed.
+   */
+  async revalidate(e, t) {
+    if (!e)
+      throw new Error("[Revalidate] Key issue: ${key}");
+    const { fetcher: s, dedupingInterval: i } = this.options, { force: a, fetcher: o, dedupingInterval: n } = {
+      ...E,
+      fetcher: s,
+      dedupingInterval: i,
+      ...t
+    };
+    if (a || !this.cache.has(e) || this.cache.has(e) && this.cache.get(e).hasExpired()) {
+      const c2 = this.requestData(e, o), l = c2.catch(() => {
+      });
+      return this.cache.set(e, new O({ data: l }).expiresIn(n)), await c2;
+    }
+    return this.getWait(e);
+  }
+  /**
+   * Mutates the data of a given key with a new value.
+   * This is used to replace the cache contents of the
+   * given key manually.
+   */
+  async mutate(e, t, s) {
+    var _a;
+    if (!e)
+      throw new Error("[Mutate] Key issue: ${key}");
+    const {
+      revalidate: i,
+      revalidateOptions: a,
+      revalidateFunction: o
+    } = {
+      ...T,
+      ...s
+    };
+    let n;
+    if (typeof t == "function") {
+      let c2;
+      if (this.cache.has(e)) {
+        const l = this.cache.get(e);
+        l.isResolving() || (c2 = l.data);
+      }
+      n = t(c2);
+    } else
+      n = t;
+    return this.cache.set(e, new O({ data: n })), i ? await ((_a = o == null ? void 0 : o(e, a)) != null ? _a : this.revalidate(e, a)) : n;
+  }
+  /**
+   * Gets the data of the given key. Keep in mind
+   * this data will be stale and revalidate in the background
+   * unless specified otherwise.
+   */
+  subscribeData(e, t) {
+    if (e) {
+      const s = (i) => t(i);
+      return this.cache.subscribe(e, s), () => this.cache.unsubscribe(e, s);
+    }
+    return () => {
+    };
+  }
+  /**
+   * Subscribes to errors on the given key.
+   */
+  subscribeErrors(e, t) {
+    if (e) {
+      const s = (i) => t(i);
+      return this.errors.subscribe(e, s), () => this.errors.unsubscribe(e, s);
+    }
+    return () => {
+    };
+  }
+  /**
+   * Gets the current cached data of the given key.
+   * This does not trigger any revalidation nor mutation
+   * of the data.
+   * - If the data has never been validated
+   * (there is no cache) it will return undefined.
+   * - If the item is pending to resolve (there is a request
+   * pending to resolve) it will return undefined.
+   */
+  get(e) {
+    if (e && this.cache.has(e)) {
+      const t = this.cache.get(e);
+      if (!t.isResolving())
+        return t.data;
+    }
+  }
+  /**
+   * Gets an element from the cache. The difference
+   * with the get is that this method returns a promise
+   * that will resolve the the value. If there's no item
+   * in the cache, it will wait for it before resolving.
+   */
+  getWait(e) {
+    return new Promise((t, s) => {
+      const i = this.subscribeData(e, (n) => {
+        if (i(), n !== void 0)
+          return t(n);
+      }), a = this.subscribeErrors(e, (n) => {
+        if (a(), n !== void 0)
+          return s(n);
+      }), o = this.get(e);
+      if (o !== void 0)
+        return t(o);
+    });
+  }
+  /**
+   * Use a SWR value given the key and
+   * subscribe to future changes.
+   */
+  subscribe(e, t, s, i) {
+    const {
+      fetcher: a,
+      fallbackData: o,
+      loadInitialCache: n,
+      revalidateOnStart: c2,
+      dedupingInterval: l,
+      revalidateOnFocus: A2,
+      focusThrottleInterval: C,
+      revalidateOnReconnect: R,
+      reconnectWhen: W2,
+      focusWhen: D2,
+      revalidateFunction: d
+    } = {
+      // Current instance options
+      // (includes default options)
+      ...this.options,
+      // Current call options.
+      ...i
+    }, K2 = (m) => {
+      var _a;
+      return (_a = d == null ? void 0 : d(this.resolveKey(e), m)) != null ? _a : this.revalidate(this.resolveKey(e), m);
+    }, f = () => K2({ fetcher: a, dedupingInterval: l }), u = n ? this.get(this.resolveKey(e)) : o != null ? o : void 0, g = c2 ? f() : Promise.resolve(void 0), M = u ? Promise.resolve(u) : g;
+    u && (t == null || t(u));
+    const v2 = t ? this.subscribeData(this.resolveKey(e), t) : void 0, b = s ? this.subscribeErrors(this.resolveKey(e), s) : void 0, p2 = D2(f, {
+      throttleInterval: C,
+      enabled: A2
+    }), w2 = W2(f, {
+      enabled: R
+    });
+    return { unsubscribe: () => {
+      v2 == null || v2(), b == null || b(), p2 == null || p2(), w2 == null || w2();
+    }, dataPromise: M, revalidatePromise: g };
+  }
+};
+
+// ../../node_modules/.pnpm/sswr@2.0.0_svelte@4.2.3/node_modules/sswr/dist/sswr.mjs
+import { beforeUpdate as w, onDestroy as E2 } from "svelte";
+function p() {
+}
+function D(t) {
+  return t();
+}
+function q2(t) {
+  t.forEach(D);
+}
+function x2(t) {
+  return typeof t == "function";
+}
+function K(t, e) {
+  return t != t ? e == e : t !== e || t && typeof t == "object" || typeof t == "function";
+}
+function z(t, ...e) {
+  if (t == null) {
+    for (const r of e)
+      r(void 0);
+    return p;
+  }
+  const n = t.subscribe(...e);
+  return n.unsubscribe ? () => n.unsubscribe() : n;
+}
+var v = [];
+function A(t, e) {
+  return {
+    subscribe: y(t, e).subscribe
+  };
+}
+function y(t, e = p) {
+  let n;
+  const r = /* @__PURE__ */ new Set();
+  function i(u) {
+    if (K(t, u) && (t = u, n)) {
+      const f = !v.length;
+      for (const s of r)
+        s[1](), v.push(s, t);
+      if (f) {
+        for (let s = 0; s < v.length; s += 2)
+          v[s][0](v[s + 1]);
+        v.length = 0;
+      }
+    }
+  }
+  function a(u) {
+    i(u(t));
+  }
+  function d(u, f = p) {
+    const s = [u, f];
+    return r.add(s), r.size === 1 && (n = e(i, a) || p), u(t), () => {
+      r.delete(s), r.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: i, update: a, subscribe: d };
+}
+function S2(t, e, n) {
+  const r = !Array.isArray(t), i = r ? [t] : t;
+  if (!i.every(Boolean))
+    throw new Error("derived() expects stores as input, got a falsy value");
+  const a = e.length < 2;
+  return A(n, (d, u) => {
+    let f = false;
+    const s = [];
+    let h2 = 0, o = p;
+    const l = () => {
+      if (h2)
+        return;
+      o();
+      const b = e(r ? s[0] : s, d, u);
+      a ? d(b) : o = x2(b) ? b : p;
+    }, g = i.map(
+      (b, m) => z(
+        b,
+        (R) => {
+          s[m] = R, h2 &= ~(1 << m), f && l();
+        },
+        () => {
+          h2 |= 1 << m;
+        }
+      )
+    );
+    return f = true, l(), function() {
+      q2(g), o(), f = false;
+    };
+  });
+}
+var O2 = class extends H {
+  /**
+   * Svelte specific use of SWR.
+   */
+  useSWR(e, n) {
+    let r;
+    const i = y(void 0, () => () => r == null ? void 0 : r()), a = y(void 0, () => () => r == null ? void 0 : r());
+    w(() => {
+      const o = (g) => {
+        a.set(void 0), i.set(g);
+      }, l = (g) => a.set(g);
+      r || (r = this.subscribe(e, o, l, {
+        loadInitialCache: true,
+        ...n
+      }).unsubscribe);
+    }), E2(() => r == null ? void 0 : r());
+    const d = (o, l) => this.mutate(this.resolveKey(e), o, {
+      revalidateOptions: n,
+      ...l
+    }), u = (o) => this.revalidate(this.resolveKey(e), { ...n, ...o }), f = (o) => this.clear(this.resolveKey(e), o), s = S2([i, a], ([o, l]) => o === void 0 && l === void 0), h2 = S2([i, a], ([o, l]) => o !== void 0 && l === void 0);
+    return { data: i, error: a, mutate: d, revalidate: u, clear: f, isLoading: s, isValid: h2 };
+  }
+};
+var W = (t) => new O2(t);
+var c = W();
+var F2 = (t, e) => c.useSWR(t, e);
+
+// svelte/use-chat.ts
+import { derived, get, writable } from "svelte/store";
+
+// shared/stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var functionCallStreamPart = {
+  code: "1",
+  name: "function_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
+      throw new Error(
+        '"function_call" parts expect an object with a "function_call" property.'
+      );
+    }
+    return {
+      type: "function_call",
+      value
+    };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var assistantMessageStreamPart = {
+  code: "4",
+  name: "assistant_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
+      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
+    )) {
+      throw new Error(
+        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
+      );
+    }
+    return {
+      type: "assistant_message",
+      value
+    };
+  }
+};
+var assistantControlDataStreamPart = {
+  code: "5",
+  name: "assistant_control_data",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
+      throw new Error(
+        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+      );
+    }
+    return {
+      type: "assistant_control_data",
+      value: {
+        threadId: value.threadId,
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var dataMessageStreamPart = {
+  code: "6",
+  name: "data_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
+      throw new Error(
+        '"data_message" parts expect an object with a "role" and "data" property.'
+      );
+    }
+    return {
+      type: "data_message",
+      value
+    };
+  }
+};
+var toolCallStreamPart = {
+  code: "7",
+  name: "tool_calls",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some(
+      (tc) => tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string"
+    )) {
+      throw new Error(
+        '"tool_calls" parts expect an object with a ToolCallPayload.'
+      );
+    }
+    return {
+      type: "tool_calls",
+      value
+    };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var streamParts = [
+  textStreamPart,
+  functionCallStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  assistantMessageStreamPart,
+  assistantControlDataStreamPart,
+  dataMessageStreamPart,
+  toolCallStreamPart,
+  messageAnnotationsStreamPart
+];
+var streamPartsByCode = {
+  [textStreamPart.code]: textStreamPart,
+  [functionCallStreamPart.code]: functionCallStreamPart,
+  [dataStreamPart.code]: dataStreamPart,
+  [errorStreamPart.code]: errorStreamPart,
+  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
+  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
+  [dataMessageStreamPart.code]: dataMessageStreamPart,
+  [toolCallStreamPart.code]: toolCallStreamPart,
+  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart
+};
+var StreamStringPrefixes = {
+  [textStreamPart.name]: textStreamPart.code,
+  [functionCallStreamPart.name]: functionCallStreamPart.code,
+  [dataStreamPart.name]: dataStreamPart.code,
+  [errorStreamPart.name]: errorStreamPart.code,
+  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
+  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
+  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
+  [toolCallStreamPart.name]: toolCallStreamPart.code,
+  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code
+};
+var validCodes = streamParts.map((part) => part.code);
+var parseStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return streamPartsByCode[code].parse(jsonValue);
+};
+
+// shared/read-data-stream.ts
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function* readDataStream(reader, {
+  isAborted
+} = {}) {
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts2 = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseStreamPart);
+    for (const streamPart of streamParts2) {
+      yield streamPart;
+    }
+    if (isAborted == null ? void 0 : isAborted()) {
+      reader.cancel();
+      break;
+    }
+  }
+}
+
+// shared/generate-id.ts
+import { customAlphabet } from "nanoid/non-secure";
+var generateId = customAlphabet(
+  "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
+  7
+);
+
+// shared/parse-complex-response.ts
+function assignAnnotationsToMessage(message, annotations) {
+  if (!message || !annotations || !annotations.length)
+    return message;
+  return { ...message, annotations: [...annotations] };
+}
+async function parseComplexResponse({
+  reader,
+  abortControllerRef,
+  update,
+  onFinish,
+  generateId: generateId2 = generateId,
+  getCurrentDate = () => /* @__PURE__ */ new Date()
+}) {
+  const createdAt = getCurrentDate();
+  const prefixMap = {
+    data: []
+  };
+  let message_annotations = void 0;
+  for await (const { type, value } of readDataStream(reader, {
+    isAborted: () => (abortControllerRef == null ? void 0 : abortControllerRef.current) === null
+  })) {
+    if (type === "text") {
+      if (prefixMap["text"]) {
+        prefixMap["text"] = {
+          ...prefixMap["text"],
+          content: (prefixMap["text"].content || "") + value
+        };
+      } else {
+        prefixMap["text"] = {
+          id: generateId2(),
+          role: "assistant",
+          content: value,
+          createdAt
+        };
+      }
+    }
+    let functionCallMessage = null;
+    if (type === "function_call") {
+      prefixMap["function_call"] = {
+        id: generateId2(),
+        role: "assistant",
+        content: "",
+        function_call: value.function_call,
+        name: value.function_call.name,
+        createdAt
+      };
+      functionCallMessage = prefixMap["function_call"];
+    }
+    let toolCallMessage = null;
+    if (type === "tool_calls") {
+      prefixMap["tool_calls"] = {
+        id: generateId2(),
+        role: "assistant",
+        content: "",
+        tool_calls: value.tool_calls,
+        createdAt
+      };
+      toolCallMessage = prefixMap["tool_calls"];
+    }
+    if (type === "data") {
+      prefixMap["data"].push(...value);
+    }
+    let responseMessage = prefixMap["text"];
+    if (type === "message_annotations") {
+      if (!message_annotations) {
+        message_annotations = [...value];
+      } else {
+        message_annotations.push(...value);
+      }
+      functionCallMessage = assignAnnotationsToMessage(
+        prefixMap["function_call"],
+        message_annotations
+      );
+      toolCallMessage = assignAnnotationsToMessage(
+        prefixMap["tool_calls"],
+        message_annotations
+      );
+      responseMessage = assignAnnotationsToMessage(
+        prefixMap["text"],
+        message_annotations
+      );
+    }
+    if (message_annotations == null ? void 0 : message_annotations.length) {
+      const messagePrefixKeys = [
+        "text",
+        "function_call",
+        "tool_calls"
+      ];
+      messagePrefixKeys.forEach((key) => {
+        if (prefixMap[key]) {
+          prefixMap[key].annotations = [...message_annotations];
+        }
+      });
+    }
+    const merged = [functionCallMessage, toolCallMessage, responseMessage].filter(Boolean).map((message) => ({
+      ...assignAnnotationsToMessage(message, message_annotations)
+    }));
+    update(merged, [...prefixMap["data"]]);
+  }
+  onFinish == null ? void 0 : onFinish(prefixMap);
+  return {
+    messages: [
+      prefixMap.text,
+      prefixMap.function_call,
+      prefixMap.tool_calls
+    ].filter(Boolean),
+    data: prefixMap.data
+  };
+}
+
+// shared/utils.ts
+function createChunkDecoder(complex) {
+  const decoder = new TextDecoder();
+  if (!complex) {
+    return function(chunk) {
+      if (!chunk)
+        return "";
+      return decoder.decode(chunk, { stream: true });
+    };
+  }
+  return function(chunk) {
+    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
+    return decoded.map(parseStreamPart).filter(Boolean);
+  };
+}
+
+// shared/call-chat-api.ts
+async function callChatApi({
+  api,
+  messages,
+  body,
+  streamMode = "stream-data",
+  credentials,
+  headers,
+  abortController,
+  restoreMessagesOnFailure,
+  onResponse,
+  onUpdate,
+  onFinish,
+  generateId: generateId2
+}) {
+  var _a;
+  const response = await fetch(api, {
+    method: "POST",
+    body: JSON.stringify({
+      messages,
+      ...body
+    }),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a = abortController == null ? void 0 : abortController()) == null ? void 0 : _a.signal,
+    credentials
+  }).catch((err) => {
+    restoreMessagesOnFailure();
+    throw err;
+  });
+  if (onResponse) {
+    try {
+      await onResponse(response);
+    } catch (err) {
+      throw err;
+    }
+  }
+  if (!response.ok) {
+    restoreMessagesOnFailure();
+    throw new Error(
+      await response.text() || "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  const reader = response.body.getReader();
+  switch (streamMode) {
+    case "text": {
+      const decoder = createChunkDecoder();
+      const resultMessage = {
+        id: generateId2(),
+        createdAt: /* @__PURE__ */ new Date(),
+        role: "assistant",
+        content: ""
+      };
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        resultMessage.content += decoder(value);
+        resultMessage.id = generateId2();
+        onUpdate([{ ...resultMessage }], []);
+        if ((abortController == null ? void 0 : abortController()) === null) {
+          reader.cancel();
+          break;
+        }
+      }
+      onFinish == null ? void 0 : onFinish(resultMessage);
+      return {
+        messages: [resultMessage],
+        data: []
+      };
+    }
+    case "stream-data": {
+      return await parseComplexResponse({
+        reader,
+        abortControllerRef: abortController != null ? { current: abortController() } : void 0,
+        update: onUpdate,
+        onFinish(prefixMap) {
+          if (onFinish && prefixMap.text != null) {
+            onFinish(prefixMap.text);
+          }
+        },
+        generateId: generateId2
+      });
+    }
+    default: {
+      const exhaustiveCheck = streamMode;
+      throw new Error(`Unknown stream mode: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// shared/process-chat-stream.ts
+async function processChatStream({
+  getStreamedResponse: getStreamedResponse2,
+  experimental_onFunctionCall,
+  experimental_onToolCall,
+  updateChatRequest,
+  getCurrentMessages
+}) {
+  while (true) {
+    const messagesAndDataOrJustMessage = await getStreamedResponse2();
+    if ("messages" in messagesAndDataOrJustMessage) {
+      let hasFollowingResponse = false;
+      for (const message of messagesAndDataOrJustMessage.messages) {
+        if ((message.function_call === void 0 || typeof message.function_call === "string") && (message.tool_calls === void 0 || typeof message.tool_calls === "string")) {
+          continue;
+        }
+        hasFollowingResponse = true;
+        if (experimental_onFunctionCall) {
+          const functionCall = message.function_call;
+          if (typeof functionCall !== "object") {
+            console.warn(
+              "experimental_onFunctionCall should not be defined when using tools"
+            );
+            continue;
+          }
+          const functionCallResponse = await experimental_onFunctionCall(
+            getCurrentMessages(),
+            functionCall
+          );
+          if (functionCallResponse === void 0) {
+            hasFollowingResponse = false;
+            break;
+          }
+          updateChatRequest(functionCallResponse);
+        }
+        if (experimental_onToolCall) {
+          const toolCalls = message.tool_calls;
+          if (!Array.isArray(toolCalls) || toolCalls.some((toolCall) => typeof toolCall !== "object")) {
+            console.warn(
+              "experimental_onToolCall should not be defined when using tools"
+            );
+            continue;
+          }
+          const toolCallResponse = await experimental_onToolCall(getCurrentMessages(), toolCalls);
+          if (toolCallResponse === void 0) {
+            hasFollowingResponse = false;
+            break;
+          }
+          updateChatRequest(toolCallResponse);
+        }
+      }
+      if (!hasFollowingResponse) {
+        break;
+      }
+    } else {
+      let fixFunctionCallArguments2 = function(response) {
+        for (const message of response.messages) {
+          if (message.tool_calls !== void 0) {
+            for (const toolCall of message.tool_calls) {
+              if (typeof toolCall === "object") {
+                if (toolCall.function.arguments && typeof toolCall.function.arguments !== "string") {
+                  toolCall.function.arguments = JSON.stringify(
+                    toolCall.function.arguments
+                  );
+                }
+              }
+            }
+          }
+          if (message.function_call !== void 0) {
+            if (typeof message.function_call === "object") {
+              if (message.function_call.arguments && typeof message.function_call.arguments !== "string") {
+                message.function_call.arguments = JSON.stringify(
+                  message.function_call.arguments
+                );
+              }
+            }
+          }
+        }
+      };
+      var fixFunctionCallArguments = fixFunctionCallArguments2;
+      const streamedResponseMessage = messagesAndDataOrJustMessage;
+      if ((streamedResponseMessage.function_call === void 0 || typeof streamedResponseMessage.function_call === "string") && (streamedResponseMessage.tool_calls === void 0 || typeof streamedResponseMessage.tool_calls === "string")) {
+        break;
+      }
+      if (experimental_onFunctionCall) {
+        const functionCall = streamedResponseMessage.function_call;
+        if (!(typeof functionCall === "object")) {
+          console.warn(
+            "experimental_onFunctionCall should not be defined when using tools"
+          );
+          continue;
+        }
+        const functionCallResponse = await experimental_onFunctionCall(getCurrentMessages(), functionCall);
+        if (functionCallResponse === void 0)
+          break;
+        fixFunctionCallArguments2(functionCallResponse);
+        updateChatRequest(functionCallResponse);
+      }
+      if (experimental_onToolCall) {
+        const toolCalls = streamedResponseMessage.tool_calls;
+        if (!(typeof toolCalls === "object")) {
+          console.warn(
+            "experimental_onToolCall should not be defined when using functions"
+          );
+          continue;
+        }
+        const toolCallResponse = await experimental_onToolCall(getCurrentMessages(), toolCalls);
+        if (toolCallResponse === void 0)
+          break;
+        fixFunctionCallArguments2(toolCallResponse);
+        updateChatRequest(toolCallResponse);
+      }
+    }
+  }
+}
+
+// svelte/use-chat.ts
+var getStreamedResponse = async (api, chatRequest, mutate, mutateStreamData, existingData, extraMetadata, previousMessages, abortControllerRef, generateId2, streamMode, onFinish, onResponse, sendExtraMessageFields) => {
+  var _a, _b;
+  mutate(chatRequest.messages);
+  const constructedMessagesPayload = sendExtraMessageFields ? chatRequest.messages : chatRequest.messages.map(
+    ({ role, content, name, function_call, tool_calls, tool_call_id }) => ({
+      role,
+      content,
+      tool_call_id,
+      ...name !== void 0 && { name },
+      ...function_call !== void 0 && {
+        function_call
+      },
+      ...tool_calls !== void 0 && {
+        tool_calls
+      }
+    })
+  );
+  return await callChatApi({
+    api,
+    messages: constructedMessagesPayload,
+    body: {
+      ...extraMetadata.body,
+      ...(_a = chatRequest.options) == null ? void 0 : _a.body,
+      ...chatRequest.functions !== void 0 && {
+        functions: chatRequest.functions
+      },
+      ...chatRequest.function_call !== void 0 && {
+        function_call: chatRequest.function_call
+      },
+      ...chatRequest.tools !== void 0 && {
+        tools: chatRequest.tools
+      },
+      ...chatRequest.tool_choice !== void 0 && {
+        tool_choice: chatRequest.tool_choice
+      }
+    },
+    streamMode,
+    credentials: extraMetadata.credentials,
+    headers: {
+      ...extraMetadata.headers,
+      ...(_b = chatRequest.options) == null ? void 0 : _b.headers
+    },
+    abortController: () => abortControllerRef,
+    restoreMessagesOnFailure() {
+      mutate(previousMessages);
+    },
+    onResponse,
+    onUpdate(merged, data) {
+      mutate([...chatRequest.messages, ...merged]);
+      mutateStreamData([...existingData || [], ...data || []]);
+    },
+    onFinish,
+    generateId: generateId2
+  });
+};
+var uniqueId = 0;
+var store = {};
+function useChat({
+  api = "/api/chat",
+  id,
+  initialMessages = [],
+  initialInput = "",
+  sendExtraMessageFields,
+  experimental_onFunctionCall,
+  experimental_onToolCall,
+  streamMode,
+  onResponse,
+  onFinish,
+  onError,
+  credentials,
+  headers,
+  body,
+  generateId: generateId2 = generateId
+} = {}) {
+  const chatId = id || `chat-${uniqueId++}`;
+  const key = `${api}|${chatId}`;
+  const {
+    data,
+    mutate: originalMutate,
+    isLoading: isSWRLoading
+  } = F2(key, {
+    fetcher: () => store[key] || initialMessages,
+    fallbackData: initialMessages
+  });
+  const streamData = writable(void 0);
+  const loading = writable(false);
+  data.set(initialMessages);
+  const mutate = (data2) => {
+    store[key] = data2;
+    return originalMutate(data2);
+  };
+  const messages = data;
+  let abortController = null;
+  const extraMetadata = {
+    credentials,
+    headers,
+    body
+  };
+  const error = writable(void 0);
+  async function triggerRequest(chatRequest) {
+    try {
+      error.set(void 0);
+      loading.set(true);
+      abortController = new AbortController();
+      await processChatStream({
+        getStreamedResponse: () => getStreamedResponse(
+          api,
+          chatRequest,
+          mutate,
+          (data2) => {
+            streamData.set(data2);
+          },
+          get(streamData),
+          extraMetadata,
+          get(messages),
+          abortController,
+          generateId2,
+          streamMode,
+          onFinish,
+          onResponse,
+          sendExtraMessageFields
+        ),
+        experimental_onFunctionCall,
+        experimental_onToolCall,
+        updateChatRequest: (chatRequestParam) => {
+          chatRequest = chatRequestParam;
+        },
+        getCurrentMessages: () => get(messages)
+      });
+      abortController = null;
+      return null;
+    } catch (err) {
+      if (err.name === "AbortError") {
+        abortController = null;
+        return null;
+      }
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+      error.set(err);
+    } finally {
+      loading.set(false);
+    }
+  }
+  const append = async (message, {
+    options,
+    functions,
+    function_call,
+    tools,
+    tool_choice
+  } = {}) => {
+    if (!message.id) {
+      message.id = generateId2();
+    }
+    const chatRequest = {
+      messages: get(messages).concat(message),
+      options,
+      ...functions !== void 0 && { functions },
+      ...function_call !== void 0 && { function_call },
+      ...tools !== void 0 && { tools },
+      ...tool_choice !== void 0 && { tool_choice }
+    };
+    return triggerRequest(chatRequest);
+  };
+  const reload = async ({
+    options,
+    functions,
+    function_call,
+    tools,
+    tool_choice
+  } = {}) => {
+    const messagesSnapshot = get(messages);
+    if (messagesSnapshot.length === 0)
+      return null;
+    const lastMessage = messagesSnapshot.at(-1);
+    if ((lastMessage == null ? void 0 : lastMessage.role) === "assistant") {
+      const chatRequest2 = {
+        messages: messagesSnapshot.slice(0, -1),
+        options,
+        ...functions !== void 0 && { functions },
+        ...function_call !== void 0 && { function_call },
+        ...tools !== void 0 && { tools },
+        ...tool_choice !== void 0 && { tool_choice }
+      };
+      return triggerRequest(chatRequest2);
+    }
+    const chatRequest = {
+      messages: messagesSnapshot,
+      options,
+      ...functions !== void 0 && { functions },
+      ...function_call !== void 0 && { function_call },
+      ...tools !== void 0 && { tools },
+      ...tool_choice !== void 0 && { tool_choice }
+    };
+    return triggerRequest(chatRequest);
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  };
+  const setMessages = (messages2) => {
+    mutate(messages2);
+  };
+  const input = writable(initialInput);
+  const handleSubmit = (e, options = {}) => {
+    e.preventDefault();
+    const inputValue = get(input);
+    if (!inputValue)
+      return;
+    append(
+      {
+        content: inputValue,
+        role: "user",
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      options
+    );
+    input.set("");
+  };
+  const isLoading = derived(
+    [isSWRLoading, loading],
+    ([$isSWRLoading, $loading]) => {
+      return $isSWRLoading || $loading;
+    }
+  );
+  return {
+    messages,
+    error,
+    append,
+    reload,
+    stop,
+    setMessages,
+    input,
+    handleSubmit,
+    isLoading,
+    data: streamData
+  };
+}
+
+// svelte/use-completion.ts
+import { derived as derived2, get as get2, writable as writable2 } from "svelte/store";
+
+// shared/call-completion-api.ts
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamMode = "stream-data",
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onResponse,
+  onFinish,
+  onError,
+  onData
+}) {
+  try {
+    setLoading(true);
+    setError(void 0);
+    const abortController = new AbortController();
+    setAbortController(abortController);
+    setCompletion("");
+    const res = await fetch(api, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...body
+      }),
+      credentials,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      signal: abortController.signal
+    }).catch((err) => {
+      throw err;
+    });
+    if (onResponse) {
+      try {
+        await onResponse(res);
+      } catch (err) {
+        throw err;
+      }
+    }
+    if (!res.ok) {
+      throw new Error(
+        await res.text() || "Failed to fetch the chat response."
+      );
+    }
+    if (!res.body) {
+      throw new Error("The response body is empty.");
+    }
+    let result = "";
+    const reader = res.body.getReader();
+    switch (streamMode) {
+      case "text": {
+        const decoder = createChunkDecoder();
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+          result += decoder(value);
+          setCompletion(result);
+          if (abortController === null) {
+            reader.cancel();
+            break;
+          }
+        }
+        break;
+      }
+      case "stream-data": {
+        for await (const { type, value } of readDataStream(reader, {
+          isAborted: () => abortController === null
+        })) {
+          switch (type) {
+            case "text": {
+              result += value;
+              setCompletion(result);
+              break;
+            }
+            case "data": {
+              onData == null ? void 0 : onData(value);
+              break;
+            }
+          }
+        }
+        break;
+      }
+      default: {
+        const exhaustiveCheck = streamMode;
+        throw new Error(`Unknown stream mode: ${exhaustiveCheck}`);
+      }
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// svelte/use-completion.ts
+var uniqueId2 = 0;
+var store2 = {};
+function useCompletion({
+  api = "/api/completion",
+  id,
+  initialCompletion = "",
+  initialInput = "",
+  credentials,
+  headers,
+  body,
+  streamMode,
+  onResponse,
+  onFinish,
+  onError
+} = {}) {
+  const completionId = id || `completion-${uniqueId2++}`;
+  const key = `${api}|${completionId}`;
+  const {
+    data,
+    mutate: originalMutate,
+    isLoading: isSWRLoading
+  } = F2(key, {
+    fetcher: () => store2[key] || initialCompletion,
+    fallbackData: initialCompletion
+  });
+  const streamData = writable2(void 0);
+  const loading = writable2(false);
+  data.set(initialCompletion);
+  const mutate = (data2) => {
+    store2[key] = data2;
+    return originalMutate(data2);
+  };
+  const completion = data;
+  const error = writable2(void 0);
+  let abortController = null;
+  const complete = async (prompt, options) => {
+    const existingData = get2(streamData);
+    return callCompletionApi({
+      api,
+      prompt,
+      credentials,
+      headers: {
+        ...headers,
+        ...options == null ? void 0 : options.headers
+      },
+      body: {
+        ...body,
+        ...options == null ? void 0 : options.body
+      },
+      streamMode,
+      setCompletion: mutate,
+      setLoading: (loadingState) => loading.set(loadingState),
+      setError: (err) => error.set(err),
+      setAbortController: (controller) => {
+        abortController = controller;
+      },
+      onResponse,
+      onFinish,
+      onError,
+      onData(data2) {
+        streamData.set([...existingData || [], ...data2 || []]);
+      }
+    });
+  };
+  const stop = () => {
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+  };
+  const setCompletion = (completion2) => {
+    mutate(completion2);
+  };
+  const input = writable2(initialInput);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    const inputValue = get2(input);
+    if (!inputValue)
+      return;
+    return complete(inputValue);
+  };
+  const isLoading = derived2(
+    [isSWRLoading, loading],
+    ([$isSWRLoading, $loading]) => {
+      return $isSWRLoading || $loading;
+    }
+  );
+  return {
+    completion,
+    complete,
+    error,
+    stop,
+    setCompletion,
+    input,
+    handleSubmit,
+    isLoading,
+    data: streamData
+  };
+}
+export {
+  useChat,
+  useCompletion
+};
+//# sourceMappingURL=index.mjs.map