@mikesaintsg/core 0.0.1

package/dist/index.js

@@ -0,0 +1,828 @@
+class O extends Error {
+  cause;
+}
+function Z(r) {
+  return r instanceof O;
+}
+class E extends Error {
+  code;
+  cause;
+  constructor(n, f, i) {
+    super(f), this.name = "CoreError", this.code = n, this.cause = i;
+  }
+}
+function Q(r) {
+  return r instanceof E;
+}
+function M(r) {
+  return { ok: !0, value: r };
+}
+function I(r) {
+  return { ok: !1, error: r };
+}
+function ee(r) {
+  return r.ok === !0;
+}
+function te(r) {
+  return !r.ok;
+}
+function ne(r, n) {
+  return r.ok ? r.value : n;
+}
+function re(r) {
+  if (r.ok)
+    return r.value;
+  throw r.error instanceof Error ? r.error : new Error(String(r.error));
+}
+function oe(r, n) {
+  return r.ok ? M(n(r.value)) : r;
+}
+function ae(r, n) {
+  return r.ok ? r : I(n(r.error));
+}
+function se(r, n) {
+  return r.ok ? n(r.value) : r;
+}
+async function P(r) {
+  const f = new TextEncoder().encode(r), i = await crypto.subtle.digest("SHA-256", f);
+  return Array.from(new Uint8Array(i)).map((e) => e.toString(16).padStart(2, "0")).join("");
+}
+function R(r) {
+  return {
+    ...r,
+    embedding: Array.from(r.embedding)
+  };
+}
+function S(r) {
+  const n = r.embedding;
+  return {
+    ...r,
+    embedding: new Float32Array(n)
+  };
+}
+function x(r) {
+  return r.byteLength;
+}
+const N = "text-embedding-3-small", F = 1536, k = "https://api.openai.com/v1", L = "voyage-2", U = 1024, B = "https://api.voyageai.com/v1", $ = 1e3, j = 100, q = 50, H = "documents", G = "metadata", v = "vectorstore_metadata", C = 100, D = "_metadata.json", T = "chunk_", J = 3e4, V = 3e4, z = 10, Y = 100, X = "You have unsaved changes. Are you sure you want to leave?";
+function ie(r) {
+  const {
+    apiKey: n,
+    model: f = N,
+    baseURL: i = k,
+    dimensions: o = F
+  } = r;
+  if (!n)
+    throw new E("ADAPTER_ERROR", "OpenAI API key is required");
+  const e = {
+    provider: "openai",
+    model: f,
+    dimensions: o
+  };
+  return {
+    async embed(a, t) {
+      if (a.length === 0)
+        return [];
+      const u = `${i}/embeddings`, s = {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${n}`
+        },
+        body: JSON.stringify({
+          input: a,
+          model: f,
+          dimensions: o
+        })
+      };
+      t?.signal && (s.signal = t.signal);
+      const l = await fetch(u, s);
+      if (!l.ok) {
+        const d = await l.text().catch(() => "Unknown error");
+        throw new E(
+          "ADAPTER_ERROR",
+          `OpenAI API error (${l.status}): ${d}`
+        );
+      }
+      return [...(await l.json()).data].sort((d, p) => d.index - p.index).map((d) => new Float32Array(d.embedding));
+    },
+    getModelMetadata() {
+      return e;
+    }
+  };
+}
+function ce(r) {
+  const {
+    apiKey: n,
+    model: f = L,
+    baseURL: i = B
+  } = r;
+  if (!n)
+    throw new E("ADAPTER_ERROR", "Voyage AI API key is required");
+  const o = {
+    provider: "anthropic",
+    model: f,
+    dimensions: U
+  };
+  return {
+    async embed(e, a) {
+      if (e.length === 0)
+        return [];
+      const t = `${i}/embeddings`, u = {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${n}`
+        },
+        body: JSON.stringify({
+          input: e,
+          model: f
+        })
+      };
+      a?.signal && (u.signal = a.signal);
+      const s = await fetch(t, u);
+      if (!s.ok) {
+        const c = await s.text().catch(() => "Unknown error");
+        throw new E(
+          "ADAPTER_ERROR",
+          `Voyage AI API error (${s.status}): ${c}`
+        );
+      }
+      return [...(await s.json()).data].sort((c, d) => c.index - d.index).map((c) => new Float32Array(c.embedding));
+    },
+    getModelMetadata() {
+      return o;
+    }
+  };
+}
+function ue(r, n = {}) {
+  const {
+    maxBatchSize: f = j,
+    flushDelayMs: i = q,
+    deduplicate: o = !0,
+    cache: e
+  } = n, a = [];
+  let t;
+  function u() {
+    t === void 0 && (t = setTimeout(() => {
+      t = void 0, s();
+    }, i));
+  }
+  async function s() {
+    if (a.length === 0) return;
+    const l = a.splice(0, a.length), y = [], c = /* @__PURE__ */ new Map();
+    for (const m of l) {
+      const h = c.get(m.contentHash);
+      h ? o ? h.push(m) : (y.push(m.text), c.set(m.contentHash + "_" + y.length, [m])) : (y.push(m.text), c.set(m.contentHash, [m]));
+    }
+    const d = [], p = [], A = /* @__PURE__ */ new Map();
+    for (const m of l) {
+      if (A.has(m.contentHash)) continue;
+      const h = e?.get(m.contentHash);
+      h ? A.set(m.contentHash, h) : p.includes(m.contentHash) || (d.push(m.text), p.push(m.contentHash));
+    }
+    try {
+      let m = [];
+      if (d.length > 0) {
+        m = await r.embed(d);
+        for (let h = 0; h < m.length; h++) {
+          const g = p[h], w = m[h];
+          g !== void 0 && w !== void 0 && (e?.set(g, w), A.set(g, w));
+        }
+      }
+      for (const h of l) {
+        const g = A.get(h.contentHash);
+        g ? h.resolve(g) : h.reject(new Error(`No embedding found for content hash: ${h.contentHash}`));
+      }
+    } catch (m) {
+      for (const h of l)
+        h.reject(m);
+    }
+  }
+  return {
+    // Passthrough methods from base adapter
+    async embed(l, y) {
+      return r.embed(l, y);
+    },
+    getModelMetadata() {
+      return r.getModelMetadata();
+    },
+    // Batched methods
+    async queue(l, y) {
+      const c = await P(l), d = e?.get(c);
+      return d || new Promise((p, A) => {
+        a.push({
+          text: l,
+          contentHash: c,
+          resolve: p,
+          reject: A
+        }), a.length >= f ? (t !== void 0 && (clearTimeout(t), t = void 0), s()) : u();
+      });
+    },
+    async queueBatch(l, y) {
+      const c = l.map((d) => this.queue(d, y));
+      return Promise.all(c);
+    },
+    async flush() {
+      t !== void 0 && (clearTimeout(t), t = void 0), await s();
+    },
+    getPendingCount() {
+      return a.length;
+    },
+    getCache() {
+      return e;
+    }
+  };
+}
+function de(r = {}) {
+  const {
+    maxEntries: n = $,
+    maxBytes: f,
+    ttlMs: i,
+    onEvict: o
+  } = r, e = /* @__PURE__ */ new Map();
+  let a = 0, t = 0;
+  function u() {
+    let c = 0;
+    for (const d of e.values())
+      c += x(d.embedding);
+    return c;
+  }
+  function s(c) {
+    return i === void 0 ? !1 : Date.now() - c.createdAt > i;
+  }
+  function l() {
+    for (; e.size > n; )
+      y();
+    if (f !== void 0)
+      for (; u() > f && e.size > 0; )
+        y();
+  }
+  function y() {
+    let c, d = 1 / 0;
+    for (const [p, A] of e.entries())
+      A.lastAccess < d && (d = A.lastAccess, c = p);
+    if (c !== void 0) {
+      const p = e.get(c);
+      e.delete(c), p && o && o(c, p.embedding);
+    }
+  }
+  return {
+    get(c) {
+      const d = e.get(c);
+      if (!d) {
+        t++;
+        return;
+      }
+      if (s(d)) {
+        e.delete(c), o && o(c, d.embedding), t++;
+        return;
+      }
+      return d.hitCount++, d.lastAccess = Date.now(), a++, d.embedding;
+    },
+    set(c, d) {
+      const p = Date.now();
+      e.set(c, {
+        embedding: d,
+        createdAt: p,
+        hitCount: 0,
+        lastAccess: p
+      }), l();
+    },
+    has(c) {
+      const d = e.get(c);
+      return d ? s(d) ? (e.delete(c), o && o(c, d.embedding), !1) : !0 : !1;
+    },
+    remove(c) {
+      const d = e.get(c);
+      return d && o && o(c, d.embedding), e.delete(c);
+    },
+    clear() {
+      if (o)
+        for (const [c, d] of e.entries())
+          o(c, d.embedding);
+      e.clear(), a = 0, t = 0;
+    },
+    getStats() {
+      const c = e.size, d = a + t;
+      return {
+        entries: c,
+        hits: a,
+        misses: t,
+        hitRate: d > 0 ? a / d : 0,
+        estimatedBytes: u()
+      };
+    }
+  };
+}
+function fe(r = {}) {
+  return {
+    formatSchemas(n) {
+      return n.map((f) => ({
+        type: "function",
+        function: {
+          name: f.name,
+          description: f.description,
+          parameters: f.parameters
+        }
+      }));
+    },
+    parseToolCalls(n) {
+      if (!n || typeof n != "object")
+        return [];
+      const i = n.choices?.[0]?.message?.tool_calls;
+      if (!i || !Array.isArray(i))
+        return [];
+      const o = [];
+      for (const e of i) {
+        if (!e || typeof e != "object" || !("id" in e) || !("function" in e)) continue;
+        const a = e.function;
+        if (!a || typeof a != "object" || !("name" in a) || !("arguments" in a)) continue;
+        let t = {};
+        try {
+          const u = JSON.parse(String(a.arguments));
+          u && typeof u == "object" && !Array.isArray(u) && (t = u);
+        } catch {
+        }
+        o.push({
+          id: String(e.id),
+          name: String(a.name),
+          arguments: t
+        });
+      }
+      return o;
+    },
+    formatResult(n) {
+      return {
+        tool_call_id: n.callId,
+        role: "tool",
+        content: n.success ? JSON.stringify(n.value) : JSON.stringify({ error: n.error })
+      };
+    }
+  };
+}
+function le(r = {}) {
+  return {
+    formatSchemas(n) {
+      return n.map((f) => ({
+        name: f.name,
+        description: f.description,
+        input_schema: f.parameters
+      }));
+    },
+    parseToolCalls(n) {
+      if (!n || typeof n != "object")
+        return [];
+      const f = n;
+      if (!f.content || !Array.isArray(f.content))
+        return [];
+      const i = [];
+      for (const o of f.content) {
+        if (!o || typeof o != "object" || !("type" in o) || o.type !== "tool_use" || !("id" in o) || !("name" in o) || !("input" in o)) continue;
+        const a = o, t = a.id, u = a.name, s = a.input;
+        typeof t != "string" || typeof u != "string" || !s || typeof s != "object" || Array.isArray(s) || i.push({
+          id: t,
+          name: u,
+          arguments: s
+        });
+      }
+      return i;
+    },
+    formatResult(n) {
+      return {
+        type: "tool_result",
+        tool_use_id: n.callId,
+        content: n.success ? JSON.stringify(n.value) : JSON.stringify({ error: n.error }),
+        is_error: !n.success
+      };
+    }
+  };
+}
+function me(r) {
+  const {
+    database: n,
+    documentsStore: f = H,
+    metadataStore: i = G
+  } = r, o = n.store(f), e = n.store(i);
+  return {
+    async load() {
+      return o.all();
+    },
+    async loadMetadata() {
+      return e.get(v);
+    },
+    async save(a) {
+      const t = Array.isArray(a) ? a : [a];
+      for (const u of t)
+        await o.set(u, u.id);
+    },
+    async saveMetadata(a) {
+      await e.set(a, v);
+    },
+    async remove(a) {
+      const t = Array.isArray(a) ? a : [a];
+      for (const u of t)
+        await o.remove(u);
+    },
+    async clear() {
+      await o.clear(), await e.clear();
+    },
+    async isAvailable() {
+      try {
+        return await o.all(), !0;
+      } catch {
+        return !1;
+      }
+    }
+  };
+}
+function ye(r) {
+  const {
+    directory: n,
+    chunkSize: f = C
+  } = r;
+  return {
+    async load() {
+      const i = await n.listFiles(), o = [];
+      for (const e of i)
+        if (e.getName().startsWith(T))
+          try {
+            const t = await e.getText(), u = JSON.parse(t);
+            for (const s of u)
+              o.push(S(s));
+          } catch {
+          }
+      return o;
+    },
+    async loadMetadata() {
+      const i = await n.getFile(D);
+      if (i)
+        try {
+          const o = await i.getText();
+          return JSON.parse(o);
+        } catch {
+          return;
+        }
+    },
+    async save(i) {
+      const o = Array.isArray(i) ? i : [i];
+      if (o.length === 0) return;
+      const e = await this.load(), a = new Map(e.map((s) => [s.id, s]));
+      for (const s of o)
+        a.set(s.id, s);
+      const t = await n.listFiles();
+      for (const s of t)
+        s.getName().startsWith(T) && await n.removeFile(s.getName());
+      const u = Array.from(a.values());
+      for (let s = 0; s < u.length; s += f) {
+        const l = u.slice(s, s + f), y = Math.floor(s / f), c = `${T}${y}.json`;
+        await (await n.createFile(c)).write(JSON.stringify(l.map(R)));
+      }
+    },
+    async saveMetadata(i) {
+      await (await n.createFile(D)).write(JSON.stringify(i));
+    },
+    async remove(i) {
+      const o = Array.isArray(i) ? i : [i], e = new Set(o), t = (await this.load()).filter((u) => !e.has(u.id));
+      await this.clear(), t.length > 0 && await this.save(t);
+    },
+    async clear() {
+      const i = await n.listFiles();
+      for (const o of i)
+        await n.removeFile(o.getName());
+    },
+    async isAvailable() {
+      try {
+        return await n.listFiles(), !0;
+      } catch {
+        return !1;
+      }
+    }
+  };
+}
+function he(r) {
+  const {
+    baseURL: n,
+    headers: f = {},
+    timeout: i = J
+  } = r;
+  async function o(e, a) {
+    const t = new AbortController(), u = setTimeout(() => t.abort(), i);
+    try {
+      return await fetch(e, {
+        ...a,
+        signal: t.signal,
+        headers: {
+          "Content-Type": "application/json",
+          ...f,
+          ...a.headers
+        }
+      });
+    } finally {
+      clearTimeout(u);
+    }
+  }
+  return {
+    async load() {
+      const e = await o(`${n}/documents`, {
+        method: "GET"
+      });
+      if (!e.ok)
+        throw new E(
+          "ADAPTER_ERROR",
+          `HTTP load failed (${e.status})`
+        );
+      return (await e.json()).map(S);
+    },
+    async loadMetadata() {
+      try {
+        const e = await o(`${n}/metadata`, {
+          method: "GET"
+        });
+        if (e.status === 404)
+          return;
+        if (!e.ok)
+          throw new E(
+            "ADAPTER_ERROR",
+            `HTTP loadMetadata failed (${e.status})`
+          );
+        return await e.json();
+      } catch (e) {
+        if (e instanceof E) throw e;
+        return;
+      }
+    },
+    async save(e) {
+      const a = Array.isArray(e) ? e : [e], t = await o(`${n}/documents`, {
+        method: "POST",
+        body: JSON.stringify(a.map(R))
+      });
+      if (!t.ok)
+        throw new E(
+          "ADAPTER_ERROR",
+          `HTTP save failed (${t.status})`
+        );
+    },
+    async saveMetadata(e) {
+      const a = await o(`${n}/metadata`, {
+        method: "PUT",
+        body: JSON.stringify(e)
+      });
+      if (!a.ok)
+        throw new E(
+          "ADAPTER_ERROR",
+          `HTTP saveMetadata failed (${a.status})`
+        );
+    },
+    async remove(e) {
+      const a = Array.isArray(e) ? e : [e], t = await o(`${n}/documents`, {
+        method: "DELETE",
+        body: JSON.stringify({ ids: a })
+      });
+      if (!t.ok)
+        throw new E(
+          "ADAPTER_ERROR",
+          `HTTP remove failed (${t.status})`
+        );
+    },
+    async clear() {
+      const e = await o(`${n}/documents`, {
+        method: "DELETE"
+      });
+      if (!e.ok)
+        throw new E(
+          "ADAPTER_ERROR",
+          `HTTP clear failed (${e.status})`
+        );
+    },
+    async isAvailable() {
+      try {
+        return (await o(`${n}/health`, {
+          method: "GET"
+        })).ok;
+      } catch {
+        return !1;
+      }
+    }
+  };
+}
+function pe(r) {
+  const {
+    registry: n,
+    timeout: f = V,
+    onError: i,
+    onBeforeExecute: o,
+    onAfterExecute: e
+  } = r;
+  async function a(t) {
+    if (!n.has(t.name))
+      return {
+        callId: t.id,
+        name: t.name,
+        success: !1,
+        error: `Tool not found: ${t.name}`
+      };
+    o?.(t);
+    try {
+      const u = new Promise((l, y) => {
+        setTimeout(() => {
+          y(new Error(`Tool execution timed out after ${f}ms`));
+        }, f);
+      }), s = await Promise.race([
+        n.execute(t.name, t.arguments),
+        u
+      ]);
+      return e?.(t, s), {
+        callId: t.id,
+        name: t.name,
+        success: !0,
+        value: s
+      };
+    } catch (u) {
+      i?.(u, t);
+      const s = u instanceof Error ? u.message : String(u);
+      return {
+        callId: t.id,
+        name: t.name,
+        success: !1,
+        error: s
+      };
+    }
+  }
+  return {
+    async execute(t) {
+      return a(t);
+    },
+    async executeAll(t) {
+      return await Promise.all(
+        t.map((s) => a(s))
+      );
+    },
+    hasTool(t) {
+      return n.has(t);
+    }
+  };
+}
+function Ae(r) {
+  const {
+    vectorStore: n,
+    name: f,
+    description: i,
+    defaultLimit: o = z,
+    maxLimit: e = Y,
+    scoreThreshold: a,
+    formatResult: t = K,
+    extendParameters: u = {},
+    buildFilter: s
+  } = r, l = {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "The search query to find relevant documents"
+      },
+      limit: {
+        type: "integer",
+        description: `Maximum number of results to return (default: ${o}, max: ${e})`,
+        minimum: 1,
+        maximum: e,
+        default: o
+      },
+      ...u
+    },
+    required: ["query"]
+  }, y = {
+    name: f,
+    description: i,
+    parameters: l
+  };
+  async function c(d) {
+    const p = d.query;
+    if (typeof p != "string" || p.length === 0)
+      return [];
+    const A = d.limit;
+    let m = o;
+    typeof A == "number" && Number.isInteger(A) && (m = Math.min(Math.max(1, A), e));
+    const h = s?.(d), g = h !== void 0 ? { limit: m, filter: h } : { limit: m }, w = await n.search(p, g);
+    let _ = w;
+    return a !== void 0 && (_ = w.filter((b) => b.score >= a)), _.map(t);
+  }
+  return { schema: y, handler: c };
+}
+function K(r) {
+  return {
+    content: r.content,
+    score: r.score,
+    metadata: r.metadata
+  };
+}
+function Ee(r) {
+  const {
+    form: n,
+    confirmFn: f,
+    message: i = X,
+    excludePages: o = [],
+    onlyFromPages: e
+  } = r;
+  return async function(t, u) {
+    return W(t, u, o, e) || !n.isDirty() ? !0 : await Promise.resolve(f(i));
+  };
+}
+function W(r, n, f, i) {
+  return !!(f.includes(r) || i !== void 0 && !i.includes(n));
+}
+function ge(r) {
+  const {
+    database: n,
+    storeName: f,
+    autoprune: i,
+    onSaveError: o
+  } = r, e = n.store(f);
+  i !== void 0 && i > 0 && a(i);
+  async function a(t) {
+    const s = Date.now() - t, l = await e.all();
+    let y = 0;
+    for (const c of l)
+      c.updatedAt < s && (await e.remove(c.id), y++);
+    return y;
+  }
+  return {
+    async save(t, u) {
+      try {
+        const s = {
+          id: t,
+          messages: [...u.getMessages()],
+          metadata: u.getMetadata(),
+          updatedAt: Date.now()
+        };
+        await e.set(s, t);
+      } catch (s) {
+        throw o?.(s, t), s;
+      }
+    },
+    async load(t) {
+      return e.get(t);
+    },
+    async delete(t) {
+      await e.remove(t);
+    },
+    async list() {
+      return (await e.all()).map((u) => u.id);
+    },
+    async prune(t) {
+      return a(t);
+    }
+  };
+}
+export {
+  V as BRIDGE_DEFAULT_TIMEOUT,
+  E as CoreError,
+  q as EMBEDDING_BATCH_DEFAULT_FLUSH_DELAY_MS,
+  j as EMBEDDING_BATCH_DEFAULT_MAX_SIZE,
+  $ as EMBEDDING_CACHE_DEFAULT_MAX_ENTRIES,
+  O as EcosystemError,
+  X as FORM_DIRTY_DEFAULT_MESSAGE,
+  J as HTTP_DEFAULT_TIMEOUT,
+  H as INDEXEDDB_DEFAULT_DOCUMENTS_STORE,
+  G as INDEXEDDB_DEFAULT_METADATA_STORE,
+  k as OPENAI_API_BASE_URL,
+  F as OPENAI_DEFAULT_EMBEDDING_DIMENSIONS,
+  N as OPENAI_DEFAULT_EMBEDDING_MODEL,
+  C as OPFS_DEFAULT_CHUNK_SIZE,
+  T as OPFS_DOCUMENTS_PREFIX,
+  D as OPFS_METADATA_FILE,
+  z as RETRIEVAL_DEFAULT_LIMIT,
+  Y as RETRIEVAL_MAX_LIMIT,
+  v as VECTORSTORE_METADATA_KEY,
+  B as VOYAGE_API_BASE_URL,
+  U as VOYAGE_DEFAULT_EMBEDDING_DIMENSIONS,
+  L as VOYAGE_DEFAULT_EMBEDDING_MODEL,
+  se as chain,
+  P as computeContentHash,
+  ce as createAnthropicEmbeddingAdapter,
+  le as createAnthropicToolFormatAdapter,
+  ue as createBatchedEmbeddingAdapter,
+  de as createEmbeddingCache,
+  Ee as createFormDirtyGuard,
+  he as createHTTPVectorStorePersistence,
+  me as createIndexedDBVectorStorePersistence,
+  ye as createOPFSVectorStorePersistence,
+  ie as createOpenAIEmbeddingAdapter,
+  fe as createOpenAIToolFormatAdapter,
+  Ae as createRetrievalTool,
+  ge as createSessionPersistence,
+  pe as createToolCallBridge,
+  S as deserializeStoredDocument,
+  I as err,
+  x as estimateEmbeddingBytes,
+  Q as isCoreError,
+  Z as isEcosystemError,
+  te as isErr,
+  ee as isOk,
+  oe as map,
+  ae as mapErr,
+  M as ok,
+  R as serializeStoredDocument,
+  ne as unwrap,
+  re as unwrapOrThrow
+};
+//# sourceMappingURL=index.js.map