vue-ai-hooks 0.2.0

package/dist/index.mjs

@@ -0,0 +1,679 @@
+var Y = Object.defineProperty;
+var Z = (u, m, s) => m in u ? Y(u, m, { enumerable: !0, configurable: !0, writable: !0, value: s }) : u[m] = s;
+var V = (u, m, s) => Z(u, typeof m != "symbol" ? m + "" : m, s);
+import { watch as q, ref as M, shallowRef as B } from "vue";
+function F(u, m) {
+  var g, i, b, l;
+  const s = u ? [...u] : [];
+  for (const a of m ?? []) {
+    const f = a.index;
+    f !== void 0 && (s[f] ? (a.id && (s[f].id = a.id), (b = a.function) != null && b.name && (s[f].function.name += a.function.name), (l = a.function) != null && l.arguments && (s[f].function.arguments += a.function.arguments)) : s[f] = {
+      id: a.id ?? "",
+      type: "function",
+      function: { name: ((g = a.function) == null ? void 0 : g.name) ?? "", arguments: ((i = a.function) == null ? void 0 : i.arguments) ?? "" }
+    });
+  }
+  return s;
+}
+function ee(u, m) {
+  const { key: s, version: g, serialize: i, deserialize: b, storage: l, onError: a } = m, f = g !== void 0 ? `${s}:v${g}` : s, p = l !== void 0 ? l : typeof window < "u" ? window.localStorage : null;
+  if (p)
+    try {
+      const C = p.getItem(f);
+      if (C !== null) {
+        const x = JSON.parse(C), t = b ? b(x) : x;
+        t != null && (u.value = t);
+      }
+    } catch {
+    }
+  p && q(
+    u,
+    (C) => {
+      try {
+        const x = i ? i(C) : C;
+        p.setItem(f, JSON.stringify(x));
+      } catch (x) {
+        a == null || a(x instanceof Error ? x : new Error(String(x)));
+      }
+    },
+    { deep: !0 }
+  );
+  function n() {
+    if (p)
+      try {
+        p.removeItem(f);
+      } catch {
+      }
+  }
+  return { clear: n };
+}
+let Q = 0;
+function W(u = "msg") {
+  return Q += 1, `${u}_${Date.now().toString(36)}_${Q.toString(36)}`;
+}
+class N extends Error {
+  constructor(s, g = {}) {
+    super(s);
+    V(this, "cause");
+    V(this, "status");
+    this.name = "AiHooksError", this.cause = g.cause, this.status = g.status;
+  }
+}
+const te = [];
+function se(u) {
+  const {
+    provider: m,
+    initialMessages: s = te,
+    defaultRequest: g = {},
+    onUpdate: i,
+    onFinish: b,
+    onError: l,
+    persist: a,
+    tools: f,
+    toolChoice: p,
+    toolHandlers: n,
+    maxToolRoundtrips: C = 1
+  } = u;
+  if (!m) throw new Error("useChat requires a provider option");
+  const x = m, t = M([...s]), d = M(""), v = M(!1), T = M(null), _ = B(null), e = a ? ee(t, {
+    key: a.key,
+    version: a.version,
+    onError: (o) => {
+      T.value = o;
+    }
+  }) : null;
+  function c(o) {
+    t.value = [...o];
+  }
+  function h() {
+    _.value && _.value.abort(), _.value = null, t.value = [], T.value = null, v.value = !1, d.value = "", e == null || e.clear();
+  }
+  function r() {
+    _.value && _.value.abort(), _.value = null, v.value = !1;
+  }
+  function A() {
+    return {
+      id: W("assistant"),
+      role: "assistant",
+      content: "",
+      createdAt: /* @__PURE__ */ new Date()
+    };
+  }
+  function $(o) {
+    return o instanceof Error ? o : new Error(String(o));
+  }
+  function y(o) {
+    const w = $(o);
+    return T.value = w, l == null || l(w), w;
+  }
+  function D(o) {
+    const w = o.function.arguments.trim();
+    if (!w) return {};
+    try {
+      return JSON.parse(w);
+    } catch (k) {
+      throw new N(`Invalid JSON arguments for tool "${o.function.name}"`, {
+        cause: k
+      });
+    }
+  }
+  function L(o) {
+    return typeof o == "string" ? o : o === void 0 ? "" : JSON.stringify(o);
+  }
+  async function S(o) {
+    const w = [];
+    for (const k of o) {
+      const R = n == null ? void 0 : n[k.function.name];
+      if (!R)
+        throw new N(`No tool handler registered for "${k.function.name}"`);
+      const P = await R(D(k), {
+        toolCall: k,
+        messages: [...t.value]
+      });
+      w.push({
+        id: W("tool"),
+        role: "tool",
+        content: L(P),
+        toolCallId: k.id,
+        createdAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return w;
+  }
+  async function E(o, w) {
+    var R;
+    const k = new AbortController();
+    _.value = k, v.value = !0, T.value = null;
+    try {
+      const P = {
+        ...g,
+        ...f && !w.tools ? { tools: f } : {},
+        ...p && !w.toolChoice ? { toolChoice: p } : {},
+        ...w,
+        signal: k.signal
+      }, I = await x.chat(P);
+      for await (const J of I) {
+        if (J.content) {
+          o.content += J.content;
+          const O = t.value.findIndex((U) => U.id === o.id);
+          O >= 0 && (t.value = [
+            ...t.value.slice(0, O),
+            { ...o },
+            ...t.value.slice(O + 1)
+          ]), i == null || i({ ...o });
+        }
+        if ((R = J.toolCalls) != null && R.length) {
+          o.toolCalls = F(o.toolCalls, J.toolCalls);
+          const O = t.value.findIndex((U) => U.id === o.id);
+          O >= 0 && (t.value = [
+            ...t.value.slice(0, O),
+            { ...o },
+            ...t.value.slice(O + 1)
+          ]);
+        }
+        if (J.finishReason) {
+          o.metadata = { ...o.metadata ?? {}, finishReason: J.finishReason };
+          const O = t.value.findIndex((U) => U.id === o.id);
+          O >= 0 && (t.value = [
+            ...t.value.slice(0, O),
+            { ...o },
+            ...t.value.slice(O + 1)
+          ]);
+        }
+      }
+      b == null || b({ ...o });
+    } catch (P) {
+      const I = $(P);
+      if (I.name === "AbortError" || k.signal.aborted) {
+        b == null || b({ ...o });
+        return;
+      }
+      throw T.value = I, l == null || l(I), I;
+    } finally {
+      _.value = null, v.value = !1;
+    }
+  }
+  async function j(o, w, k) {
+    await E(o, w);
+    const R = o.toolCalls;
+    if (!n || !(R != null && R.length)) return;
+    if (k <= 0)
+      throw y(new N("Maximum tool roundtrips exceeded"));
+    v.value = !0;
+    let P;
+    try {
+      P = await S(R);
+    } catch (J) {
+      throw v.value = !1, y(J);
+    }
+    const I = A();
+    t.value = [...t.value, ...P, I], await j(
+      I,
+      { messages: t.value.filter((J) => J.id !== I.id) },
+      k - 1
+    );
+  }
+  async function z(o, w = {}) {
+    const k = typeof o == "string" ? { id: W("user"), role: "user", content: o, createdAt: /* @__PURE__ */ new Date() } : { ...o, id: o.id || W(o.role) }, R = A();
+    t.value = [...t.value, k, R], await j(
+      R,
+      {
+        messages: t.value.filter((P) => P.id !== R.id),
+        ...w
+      },
+      C
+    );
+  }
+  async function H() {
+    var R;
+    const o = (R = [...t.value].map((P, I) => ({ m: P, i: I })).reverse().find(({ m: P }) => P.role === "assistant")) == null ? void 0 : R.i;
+    if (o === void 0)
+      throw new N("reload() called with no assistant message to re-run");
+    const w = t.value.slice(0, o), k = A();
+    t.value = [...w, k], await j(k, { messages: w }, C);
+  }
+  return {
+    messages: t,
+    input: d,
+    isLoading: v,
+    error: T,
+    append: z,
+    reload: H,
+    stop: r,
+    setMessages: c,
+    clear: h,
+    abortController: _
+  };
+}
+function re(u) {
+  const { provider: m, initialCompletion: s = "", defaultRequest: g = {}, onFinish: i, onError: b } = u, l = M(s), a = M(""), f = M(!1), p = M(null), n = B(null);
+  function C() {
+    n.value && n.value.abort(), n.value = null, f.value = !1;
+  }
+  function x(d) {
+    l.value = d;
+  }
+  async function t(d, v = {}) {
+    const T = d ?? a.value;
+    if (!T)
+      throw new Error("complete() requires a prompt (either as argument or via input.value)");
+    const _ = new AbortController();
+    n.value = _, f.value = !0, p.value = null, l.value = "";
+    try {
+      const e = await m.completion({
+        ...g,
+        ...v,
+        prompt: T,
+        signal: _.signal,
+        stream: !0
+      });
+      for await (const c of e)
+        l.value += c;
+      return i == null || i(l.value), l.value;
+    } catch (e) {
+      const c = e instanceof Error ? e : new Error(String(e));
+      if (c.name === "AbortError" || _.signal.aborted)
+        return i == null || i(l.value), l.value;
+      throw p.value = c, b == null || b(c), c;
+    } finally {
+      n.value = null, f.value = !1;
+    }
+  }
+  return {
+    completion: l,
+    input: a,
+    isLoading: f,
+    error: p,
+    complete: t,
+    stop: C,
+    setCompletion: x,
+    abortController: n
+  };
+}
+function ie(u) {
+  const { provider: m, defaultRequest: s = {}, onSuccess: g, onError: i } = u, b = M([]), l = M(!1), a = M(null), f = B(null), p = B(null);
+  async function n(C, x = {}) {
+    const t = new AbortController();
+    p.value = t, l.value = !0, a.value = null;
+    try {
+      const d = await m.embedding({
+        ...s,
+        ...x,
+        input: C,
+        signal: t.signal
+      });
+      return b.value = d.embeddings, f.value = d, g == null || g(d), d;
+    } catch (d) {
+      const v = d instanceof Error ? d : new Error(String(d));
+      throw a.value = v, i == null || i(v), v;
+    } finally {
+      p.value = null, l.value = !1;
+    }
+  }
+  return {
+    embeddings: b,
+    isLoading: l,
+    error: a,
+    result: f,
+    embed: n,
+    abortController: p
+  };
+}
+async function* G(u, m) {
+  if (!u.body)
+    throw new Error("Response has no body");
+  const s = u.body.getReader(), g = new TextDecoder("utf-8");
+  let i = "";
+  try {
+    for (; ; ) {
+      if (m != null && m.aborted) {
+        await s.cancel();
+        return;
+      }
+      const { done: b, value: l } = await s.read();
+      if (b) break;
+      i += g.decode(l, { stream: !0 }).replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+      let a;
+      for (; (a = i.indexOf(`
+
+`)) !== -1; ) {
+        const f = i.slice(0, a);
+        i = i.slice(a + 2);
+        for (const p of f.split(`
+`)) {
+          if (!p.startsWith("data:")) continue;
+          const n = p.slice(5).trim();
+          if (n === "[DONE]") return;
+          if (n)
+            try {
+              yield JSON.parse(n);
+            } catch {
+            }
+        }
+      }
+    }
+  } finally {
+    s.releaseLock();
+  }
+}
+async function K(u, m = {}) {
+  const { timeoutMs: s, signal: g, fetcher: i, ...b } = m, l = i ?? (typeof globalThis.fetch == "function" ? globalThis.fetch.bind(globalThis) : void 0);
+  if (!l)
+    throw new N("No fetch implementation available");
+  const a = new AbortController(), f = () => a.abort();
+  g && (g.aborted ? a.abort() : g.addEventListener("abort", f, { once: !0 }));
+  let p;
+  s && s > 0 && (p = setTimeout(() => a.abort(), s));
+  try {
+    const n = await l(u, { ...b, signal: a.signal });
+    if (!n.ok) {
+      let C;
+      try {
+        C = await n.json();
+      } catch {
+        C = await n.text().catch(() => {
+        });
+      }
+      throw new N(
+        `Request failed with status ${n.status} ${n.statusText}`,
+        { status: n.status, cause: C }
+      );
+    }
+    return n;
+  } catch (n) {
+    throw n instanceof N ? n : (n == null ? void 0 : n.name) === "AbortError" ? new N("Request aborted", { cause: n }) : new N("Network error", { cause: n });
+  } finally {
+    p && clearTimeout(p), g && g.removeEventListener("abort", f);
+  }
+}
+function oe(u) {
+  const {
+    apiKey: m,
+    baseURL: s,
+    headers: g = {},
+    defaultModel: i,
+    chatPath: b = "/chat/completions",
+    completionPath: l = "/completions",
+    embeddingPath: a = "/embeddings",
+    fetch: f
+  } = u, p = {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${m}`,
+    ...g
+  }, n = (x, t) => {
+    const d = x.replace(/\/+$/, ""), v = t.startsWith("/") ? t : `/${t}`;
+    return `${d}${v}`;
+  };
+  function C(x) {
+    return x.map((t) => {
+      var v;
+      const d = { role: t.role, content: t.content };
+      return t.name && (d.name = t.name), t.toolCallId && (d.tool_call_id = t.toolCallId), (v = t.toolCalls) != null && v.length && (d.tool_calls = t.toolCalls), d;
+    });
+  }
+  return {
+    id: "openai-compatible",
+    async chat(x) {
+      const {
+        messages: t,
+        model: d = i,
+        temperature: v,
+        maxTokens: T,
+        topP: _,
+        frequencyPenalty: e,
+        presencePenalty: c,
+        stop: h,
+        tools: r,
+        toolChoice: A,
+        user: $,
+        stream: y = !0,
+        signal: D,
+        headers: L
+      } = x, S = {
+        model: d,
+        messages: C(t),
+        stream: y
+      };
+      v !== void 0 && (S.temperature = v), T !== void 0 && (S.max_tokens = T), _ !== void 0 && (S.top_p = _), e !== void 0 && (S.frequency_penalty = e), c !== void 0 && (S.presence_penalty = c), h !== void 0 && (S.stop = h), r && (S.tools = r), A && (S.tool_choice = A), $ && (S.user = $);
+      const E = await K(n(s, b), {
+        method: "POST",
+        headers: { ...p, ...L },
+        body: JSON.stringify(S),
+        signal: D,
+        fetcher: f
+      });
+      if (!y) {
+        const j = await E.json();
+        return async function* () {
+          var z, H, o, w, k;
+          yield {
+            content: ((o = (H = (z = j.choices) == null ? void 0 : z[0]) == null ? void 0 : H.message) == null ? void 0 : o.content) ?? "",
+            finishReason: ((k = (w = j.choices) == null ? void 0 : w[0]) == null ? void 0 : k.finish_reason) ?? "stop",
+            usage: j.usage
+          };
+        }();
+      }
+      return async function* () {
+        var j, z, H;
+        for await (const o of G(E, D)) {
+          const w = (j = o.choices) == null ? void 0 : j[0];
+          if (!w) continue;
+          const k = o.usage;
+          yield {
+            content: (z = w.delta) == null ? void 0 : z.content,
+            toolCalls: (H = w.delta) == null ? void 0 : H.tool_calls,
+            finishReason: w.finish_reason ?? void 0,
+            usage: k
+          };
+        }
+      }();
+    },
+    async completion(x) {
+      const {
+        prompt: t,
+        model: d = i,
+        temperature: v,
+        maxTokens: T,
+        topP: _,
+        frequencyPenalty: e,
+        presencePenalty: c,
+        stop: h,
+        stream: r = !0,
+        signal: A,
+        headers: $
+      } = x, y = { model: d, prompt: t, stream: r };
+      v !== void 0 && (y.temperature = v), T !== void 0 && (y.max_tokens = T), _ !== void 0 && (y.top_p = _), e !== void 0 && (y.frequency_penalty = e), c !== void 0 && (y.presence_penalty = c), h !== void 0 && (y.stop = h);
+      const D = await K(n(s, l), {
+        method: "POST",
+        headers: { ...p, ...$ },
+        body: JSON.stringify(y),
+        signal: A,
+        fetcher: f
+      });
+      if (!r) {
+        const L = await D.json();
+        return async function* () {
+          var S, E;
+          yield ((E = (S = L.choices) == null ? void 0 : S[0]) == null ? void 0 : E.text) ?? "";
+        }();
+      }
+      return async function* () {
+        var L;
+        for await (const S of G(D, A)) {
+          const E = (L = S.choices) == null ? void 0 : L[0];
+          E != null && E.text && (yield E.text);
+        }
+      }();
+    },
+    async embedding(x) {
+      const { input: t, model: d = i, user: v, signal: T, headers: _ } = x, e = { input: t };
+      d && (e.model = d), v && (e.user = v);
+      const h = await (await K(n(s, a), {
+        method: "POST",
+        headers: { ...p, ..._ },
+        body: JSON.stringify(e),
+        signal: T,
+        fetcher: f
+      })).json();
+      return {
+        embeddings: h.data.map((r) => r.embedding),
+        model: h.model,
+        usage: {
+          promptTokens: h.usage.prompt_tokens,
+          totalTokens: h.usage.total_tokens
+        }
+      };
+    }
+  };
+}
+function le(u) {
+  return oe({
+    baseURL: "https://api.openai.com/v1",
+    defaultModel: "gpt-4o-mini",
+    ...u
+  });
+}
+function X(u) {
+  switch (u) {
+    case "end_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool_calls";
+    default:
+      return "stop";
+  }
+}
+function ce(u) {
+  const {
+    apiKey: m,
+    baseURL: s = "https://api.anthropic.com",
+    defaultModel: g = "claude-3-5-sonnet-20241022",
+    maxTokens: i = 1024,
+    anthropicVersion: b = "2023-06-01",
+    headers: l = {},
+    fetch: a
+  } = u, f = {
+    "Content-Type": "application/json",
+    "x-api-key": m,
+    "anthropic-version": b,
+    ...l
+  }, p = (e) => {
+    const c = s.replace(/\/+$/, ""), h = e.startsWith("/") ? e : `/${e}`;
+    return `${c}${h}`;
+  };
+  function n(e) {
+    return typeof e == "string" ? e : e.map((c) => C(c));
+  }
+  function C(e) {
+    if (e.type === "text")
+      return { type: "text", text: e.text };
+    const c = e.image_url.url;
+    if (c.startsWith("data:")) {
+      const h = c.match(/^data:([^;]+);base64,(.*)$/s);
+      if (h)
+        return {
+          type: "image",
+          source: { type: "base64", media_type: h[1], data: h[2] }
+        };
+    }
+    return { type: "image", source: { type: "url", url: c } };
+  }
+  function x(e) {
+    const c = [], h = [];
+    for (const r of e)
+      r.role === "system" ? typeof r.content == "string" && r.content && c.push(r.content) : (r.role === "user" || r.role === "assistant") && h.push({ role: r.role, content: n(r.content) });
+    return {
+      system: c.length ? c.join(`
+
+`) : void 0,
+      messages: h
+    };
+  }
+  function t(e) {
+    const { system: c, messages: h } = x(e.messages), r = {
+      model: e.model ?? g,
+      messages: h,
+      max_tokens: e.maxTokens ?? i,
+      stream: e.stream ?? !0
+    };
+    return c && (r.system = c), e.temperature !== void 0 && (r.temperature = e.temperature), e.topP !== void 0 && (r.top_p = e.topP), e.stop !== void 0 && (r.stop_sequences = Array.isArray(e.stop) ? e.stop : [e.stop]), e.user && (r.metadata = { user_id: e.user }), r;
+  }
+  async function d(e) {
+    const c = t({ ...e, stream: e.stream ?? !0 }), h = await K(p("/v1/messages"), {
+      method: "POST",
+      headers: { ...f, ...e.headers },
+      body: JSON.stringify(c),
+      signal: e.signal,
+      fetcher: a
+    });
+    if (e.stream === !1) {
+      const r = await h.json();
+      return async function* () {
+        const A = r.content.find(($) => $.type === "text");
+        yield {
+          content: (A == null ? void 0 : A.text) ?? "",
+          finishReason: X(r.stop_reason),
+          usage: r.usage ? {
+            promptTokens: r.usage.input_tokens,
+            completionTokens: r.usage.output_tokens,
+            totalTokens: r.usage.input_tokens + r.usage.output_tokens
+          } : void 0
+        };
+      }();
+    }
+    return async function* () {
+      var r;
+      for await (const A of G(h, e.signal)) {
+        const $ = A.type;
+        if ($ === "content_block_delta") {
+          const y = A.delta;
+          (y == null ? void 0 : y.type) === "text_delta" && typeof y.text == "string" && (yield { content: y.text });
+        } else if ($ === "message_delta") {
+          const y = (r = A.delta) == null ? void 0 : r.stop_reason;
+          y && (yield { finishReason: X(y) });
+        } else if ($ === "error") {
+          const y = A.error;
+          throw new N(
+            `Anthropic API error: ${(y == null ? void 0 : y.type) ?? "unknown"}: ${(y == null ? void 0 : y.message) ?? "unknown"}`,
+            { cause: A }
+          );
+        }
+      }
+    }();
+  }
+  async function v(e) {
+    return (async function* () {
+      const c = await this.chat({
+        ...e,
+        messages: [{ id: "prompt", role: "user", content: e.prompt }]
+      });
+      for await (const h of c)
+        h.content && (yield h.content);
+    }).call(_);
+  }
+  async function T() {
+    throw new N("Anthropic has no embedding API", { status: 501 });
+  }
+  const _ = {
+    id: "anthropic",
+    chat: d,
+    completion: v,
+    embedding: T
+  };
+  return _;
+}
+export {
+  N as AiHooksError,
+  ce as anthropic,
+  le as openai,
+  oe as openaiCompatible,
+  se as useChat,
+  re as useCompletion,
+  ie as useEmbedding,
+  ee as usePersist
+};

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,40 @@
+import type { ChatProvider } from './types';
+/** Configuration for the Anthropic provider. */
+export interface AnthropicConfig {
+    /** Your Anthropic API key. */
+    apiKey: string;
+    /** Base URL. Defaults to https://api.anthropic.com */
+    baseURL?: string;
+    /** Default model when a request omits one. Defaults to claude-3-5-sonnet. */
+    defaultModel?: string;
+    /** Default max_tokens. Anthropic requires this. Defaults to 1024. */
+    maxTokens?: number;
+    /** Anthropic API version header. Defaults to 2023-06-01. */
+    anthropicVersion?: string;
+    /** Additional headers. */
+    headers?: Record<string, string>;
+    /** Custom fetch implementation. */
+    fetch?: typeof fetch;
+}
+/**
+ * Build an Anthropic Claude provider. Compatible with the Claude 3 / 3.5 / 4
+ * family on the official API and on proxies that follow the same wire format.
+ *
+ * ```ts
+ * import { useChat, anthropic } from 'vue-ai-hooks'
+ *
+ * const { messages, append } = useChat({
+ *   provider: anthropic({ apiKey: import.meta.env.VITE_ANTHROPIC_KEY })
+ * })
+ * ```
+ *
+ * Notes:
+ * - Anthropic has no embeddings API. Calling `useEmbedding` with this provider
+ *   throws a clear `AiHooksError`.
+ * - Anthropic has no `/v1/completions` endpoint. `useCompletion` is implemented
+ *   as a single-turn chat with a user message.
+ * - The system prompt is a top-level field, not part of `messages[]`. The
+ *   adapter extracts any `role: 'system'` messages and joins them.
+ */
+export declare function anthropic(config: AnthropicConfig): ChatProvider;
+//# sourceMappingURL=anthropic.d.ts.map