@lunora/ai 1.0.0-alpha.13 → 1.0.0-alpha.14

package/dist/index.d.mts

@@ -1,31 +1,6 @@
-import { EmbeddingModel, LanguageModel } from 'ai';
-export { type EmbeddingModel, type LanguageModel, embed, embedMany, generateObject, generateText, streamObject, streamText, tool } from 'ai';
+import { L as LunoraAiOptions, a as LunoraAi } from "./packem_shared/types.d-C6dA8LCy.mjs";
+export type { A as AiBindingLike, b as AiGatewayOptions, E as EmbeddingModelInput, M as ModelInput, W as WorkersAiProviderLike } from "./packem_shared/types.d-C6dA8LCy.mjs";
+export { type EmbeddingModel, type LanguageModel, embed, embedMany, generateObject, generateText, hasToolCall, jsonSchema, streamObject, streamText, tool } from 'ai';
 export { createWorkersAI } from 'workers-ai-provider';
-interface AiBindingLike {
-  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
-}
-interface WorkersAiProviderLike {
-  (modelId: string, settings?: Record<string, unknown>): LanguageModel;
-  textEmbeddingModel?: (modelId: string) => EmbeddingModel;
-}
-interface AiGatewayOptions {
-  [key: string]: unknown;
-  id: string;
-}
-interface LunoraAiOptions {
-  binding?: AiBindingLike;
-  defaultEmbeddingModel?: string;
-  defaultModel?: string;
-  gateway?: AiGatewayOptions;
-  provider?: WorkersAiProviderLike;
-}
-type ModelInput = LanguageModel;
-type EmbeddingModelInput = EmbeddingModel | string;
-interface LunoraAi {
-  embeddingModel: (model?: EmbeddingModelInput) => EmbeddingModel;
-  model: (model?: ModelInput) => LanguageModel;
-  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
-  workersai: WorkersAiProviderLike;
-}
 declare const createAi: (options: LunoraAiOptions) => LunoraAi;
-export { type AiBindingLike, type AiGatewayOptions, type EmbeddingModelInput, type LunoraAi, type LunoraAiOptions, type ModelInput, type WorkersAiProviderLike, createAi };
+export { type LunoraAi, type LunoraAiOptions, createAi };

package/dist/index.d.ts

@@ -1,31 +1,6 @@
-import { EmbeddingModel, LanguageModel } from 'ai';
-export { type EmbeddingModel, type LanguageModel, embed, embedMany, generateObject, generateText, streamObject, streamText, tool } from 'ai';
+import { L as LunoraAiOptions, a as LunoraAi } from "./packem_shared/types.d-C6dA8LCy.js";
+export type { A as AiBindingLike, b as AiGatewayOptions, E as EmbeddingModelInput, M as ModelInput, W as WorkersAiProviderLike } from "./packem_shared/types.d-C6dA8LCy.js";
+export { type EmbeddingModel, type LanguageModel, embed, embedMany, generateObject, generateText, hasToolCall, jsonSchema, streamObject, streamText, tool } from 'ai';
 export { createWorkersAI } from 'workers-ai-provider';
-interface AiBindingLike {
-  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
-}
-interface WorkersAiProviderLike {
-  (modelId: string, settings?: Record<string, unknown>): LanguageModel;
-  textEmbeddingModel?: (modelId: string) => EmbeddingModel;
-}
-interface AiGatewayOptions {
-  [key: string]: unknown;
-  id: string;
-}
-interface LunoraAiOptions {
-  binding?: AiBindingLike;
-  defaultEmbeddingModel?: string;
-  defaultModel?: string;
-  gateway?: AiGatewayOptions;
-  provider?: WorkersAiProviderLike;
-}
-type ModelInput = LanguageModel;
-type EmbeddingModelInput = EmbeddingModel | string;
-interface LunoraAi {
-  embeddingModel: (model?: EmbeddingModelInput) => EmbeddingModel;
-  model: (model?: ModelInput) => LanguageModel;
-  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
-  workersai: WorkersAiProviderLike;
-}
 declare const createAi: (options: LunoraAiOptions) => LunoraAi;
-export { type AiBindingLike, type AiGatewayOptions, type EmbeddingModelInput, type LunoraAi, type LunoraAiOptions, type ModelInput, type WorkersAiProviderLike, createAi };
+export { type LunoraAi, type LunoraAiOptions, createAi };

package/dist/index.mjs

@@ -1,3 +1,3 @@
 export { default as createAi } from './packem_shared/createAi-CYxQuvEL.mjs';
-export { embed, embedMany, generateObject, generateText, streamObject, streamText, tool } from 'ai';
+export { embed, embedMany, generateObject, generateText, hasToolCall, jsonSchema, streamObject, streamText, tool } from 'ai';
 export { createWorkersAI } from 'workers-ai-provider';

package/dist/packem_shared/bm25LexicalStore-Q28z6fbO.mjs

@@ -0,0 +1,118 @@
+const BM25_K1 = 1.5;
+const BM25_B = 0.75;
+const TOKEN_PATTERN = /[a-z0-9]+/g;
+const tokenize = (text) => text.toLowerCase().match(TOKEN_PATTERN) ?? [];
+const isPrimitiveFilter = (filter) => Object.values(filter).every((value) => value === null || typeof value !== "object");
+const filterWarned = /* @__PURE__ */ new WeakSet();
+const bm25LexicalStore = () => {
+  const namespaces = /* @__PURE__ */ new Map();
+  const stateFor = (namespace = "") => {
+    let state = namespaces.get(namespace);
+    if (!state) {
+      state = { documents: /* @__PURE__ */ new Map(), postings: /* @__PURE__ */ new Map(), totalLength: 0 };
+      namespaces.set(namespace, state);
+    }
+    return state;
+  };
+  const removeDocument = (namespace, id) => {
+    const state = stateFor(namespace);
+    const existing = state.documents.get(id);
+    if (!existing) {
+      return;
+    }
+    for (const term of existing.termFrequency.keys()) {
+      const posting = state.postings.get(term);
+      if (posting) {
+        posting.delete(id);
+        if (posting.size === 0) {
+          state.postings.delete(term);
+        }
+      }
+    }
+    state.totalLength -= existing.length;
+    state.documents.delete(id);
+  };
+  const store = {
+    index: (chunks, options) => {
+      const state = stateFor(options.namespace);
+      for (const chunk of chunks) {
+        removeDocument(options.namespace, chunk.id);
+        const tokens = tokenize(chunk.text);
+        if (tokens.length === 0) {
+          continue;
+        }
+        const termFrequency = /* @__PURE__ */ new Map();
+        for (const token of tokens) {
+          termFrequency.set(token, (termFrequency.get(token) ?? 0) + 1);
+        }
+        for (const [term, frequency] of termFrequency) {
+          let posting = state.postings.get(term);
+          if (!posting) {
+            posting = /* @__PURE__ */ new Map();
+            state.postings.set(term, posting);
+          }
+          posting.set(chunk.id, frequency);
+        }
+        state.documents.set(chunk.id, { length: tokens.length, termFrequency, text: chunk.text });
+        state.totalLength += tokens.length;
+      }
+      return Promise.resolve();
+    },
+    remove: (ids, options) => {
+      for (const id of ids) {
+        removeDocument(options.namespace, id);
+      }
+      return Promise.resolve();
+    },
+    search: (query, options) => {
+      if (options.filter && Object.keys(options.filter).length > 0 && !isPrimitiveFilter(options.filter)) {
+        if (!filterWarned.has(store)) {
+          filterWarned.add(store);
+          console.warn(
+            "[@lunora/ai/rag] bm25LexicalStore cannot evaluate a metadata filter (it stores no metadata);\nthe lexical leg is skipped for filtered queries. Fold the RLS dimension into `namespace`,\nor plug a filter-aware RagLexicalStore, to keep a lexical leg under metadata-based RLS."
+          );
+        }
+        return Promise.resolve([]);
+      }
+      const state = stateFor(options.namespace);
+      const documentCount = state.documents.size;
+      if (documentCount === 0) {
+        return Promise.resolve([]);
+      }
+      const queryTerms = [...new Set(tokenize(query))];
+      if (queryTerms.length === 0) {
+        return Promise.resolve([]);
+      }
+      const averageLength = state.totalLength / documentCount;
+      const scores = /* @__PURE__ */ new Map();
+      for (const term of queryTerms) {
+        const posting = state.postings.get(term);
+        if (!posting) {
+          continue;
+        }
+        const documentFrequency = posting.size;
+        const idf = Math.log(1 + (documentCount - documentFrequency + 0.5) / (documentFrequency + 0.5));
+        for (const [id, frequency] of posting) {
+          const document = state.documents.get(id);
+          if (!document) {
+            continue;
+          }
+          const denominator = frequency + BM25_K1 * (1 - BM25_B + BM25_B * document.length / averageLength);
+          const contribution = idf * (frequency * (BM25_K1 + 1) / denominator);
+          scores.set(id, (scores.get(id) ?? 0) + contribution);
+        }
+      }
+      const matches = [...scores.entries()].map(([id, score]) => {
+        return {
+          id,
+          score,
+          text: state.documents.get(id)?.text ?? ""
+        };
+      });
+      return Promise.resolve(matches.toSorted((a, b) => b.score - a.score).slice(0, options.topK));
+    }
+  };
+  return store;
+};
+
+export { bm25LexicalStore as default };

package/dist/packem_shared/contentHash-Cgz5KRGD.mjs

@@ -0,0 +1,92 @@
+const DOT_PREFIX_RE = /^\.+/u;
+const EXTENSION_MIME_MAP = {
+  // Images
+  avif: "image/avif",
+  bmp: "image/bmp",
+  gif: "image/gif",
+  ico: "image/x-icon",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  webp: "image/webp",
+  // Video
+  avi: "video/x-msvideo",
+  mkv: "video/x-matroska",
+  mov: "video/quicktime",
+  mp4: "video/mp4",
+  mpeg: "video/mpeg",
+  mpg: "video/mpeg",
+  webm: "video/webm",
+  wmv: "video/x-ms-wmv",
+  // Audio
+  aac: "audio/aac",
+  flac: "audio/flac",
+  m4a: "audio/mp4",
+  mp3: "audio/mpeg",
+  ogg: "audio/ogg",
+  opus: "audio/opus",
+  wav: "audio/wav",
+  wma: "audio/x-ms-wma",
+  // Documents (office / PDF)
+  csv: "text/csv",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  odp: "application/vnd.oasis.opendocument.presentation",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  odt: "application/vnd.oasis.opendocument.text",
+  pdf: "application/pdf",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  rtf: "application/rtf",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  // Text / markup
+  css: "text/css",
+  html: "text/html",
+  htm: "text/html",
+  ini: "text/plain",
+  json: "application/json",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  md: "text/markdown",
+  jsx: "text/javascript",
+  ts: "text/typescript",
+  tsx: "text/typescript",
+  txt: "text/plain",
+  xml: "application/xml",
+  yaml: "application/x-yaml",
+  yml: "application/x-yaml",
+  // Archives / binaries
+  "7z": "application/x-7z-compressed",
+  bz2: "application/x-bzip2",
+  gz: "application/gzip",
+  jar: "application/java-archive",
+  rar: "application/vnd.rar",
+  tar: "application/x-tar",
+  zip: "application/zip",
+  // Fonts
+  otf: "font/otf",
+  ttf: "font/ttf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  // Other common
+  bin: "application/octet-stream",
+  epub: "application/epub+zip",
+  exe: "application/vnd.microsoft.portable-executable",
+  iso: "application/x-iso9660-image",
+  sql: "application/sql",
+  toml: "application/toml"
+};
+const guessMimeTypeFromExtension = (extension) => {
+  const normalizedExtension = extension.replace(DOT_PREFIX_RE, "").toLowerCase();
+  return EXTENSION_MIME_MAP[normalizedExtension] ?? "application/octet-stream";
+};
+const contentHash = async (data) => {
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+
+export { contentHash, guessMimeTypeFromExtension };

package/dist/packem_shared/defineRag-BwrgePLE.mjs

@@ -0,0 +1,402 @@
+import { LunoraError } from '@lunora/errors';
+import { tool, jsonSchema, embed } from 'ai';
+import fixedWindowChunks from './fixedWindowChunks-J-WfQDw9.mjs';
+import hybridRank from './hybridRank-DPC9c2ON.mjs';
+
+const INDEX_CONCURRENCY = 8;
+const concurrentMap = async (items, limit, function_) => {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new RangeError("concurrentMap: `limit` must be a positive integer");
+  }
+  const results = Array.from({ length: items.length });
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor;
+      cursor += 1;
+      results[index] = await function_(items[index], index);
+    }
+  };
+  const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+  await Promise.all(workers);
+  return results;
+};
+
+const DEFAULT_CHUNK_SIZE = 1e3;
+const DEFAULT_CHUNK_OVERLAP = 200;
+const DEFAULT_TOP_K = 5;
+const MAX_TOP_K_FULL_METADATA = 20;
+const MAX_TOP_K = 100;
+const CHUNK_INDEX_KEY = "__ragChunk";
+const SOURCE_KEY = "__ragSource";
+const TEXT_KEY = "__ragText";
+const HASH_KEY = "__ragHash";
+const COUNT_KEY = "__ragChunks";
+const IMPORTANCE_KEY = "__ragImportance";
+const MODEL_KEY = "__ragModel";
+const INTERNAL_KEYS = /* @__PURE__ */ new Set([CHUNK_INDEX_KEY, COUNT_KEY, HASH_KEY, IMPORTANCE_KEY, MODEL_KEY, SOURCE_KEY, TEXT_KEY]);
+const MODEL_VERSION_PATTERN = /^[\w.-]{1,40}$/;
+const namespacePrefix = (namespace) => namespace === void 0 ? "" : `${encodeURIComponent(namespace)}#`;
+const chunkVectorId = (namespace, sourceId, chunkIndex) => `${namespacePrefix(namespace)}${sourceId}#${String(chunkIndex)}`;
+const parseChunkVectorId = (id, namespace) => {
+  const prefix = namespacePrefix(namespace);
+  const body = prefix !== "" && id.startsWith(prefix) ? id.slice(prefix.length) : id;
+  const separator = body.lastIndexOf("#");
+  const chunkIndex = separator === -1 ? Number.NaN : Number(body.slice(separator + 1));
+  if (separator === -1 || !Number.isInteger(chunkIndex) || chunkIndex < 0) {
+    return { chunkIndex: 0, sourceId: body };
+  }
+  return { chunkIndex, sourceId: body.slice(0, separator) };
+};
+const sha256Hex = async (text) => {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const userMetadataOf = (metadata) => {
+  if (!metadata) {
+    return void 0;
+  }
+  const entries = Object.entries(metadata).filter(([key]) => !INTERNAL_KEYS.has(key));
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+const sharedNamespaceWarned = /* @__PURE__ */ new Set();
+const warnSharedNamespace = (indexName) => {
+  if (sharedNamespaceWarned.has(indexName)) {
+    return;
+  }
+  sharedNamespaceWarned.add(indexName);
+  console.warn(
+    `[@lunora/ai/rag] index "${indexName}" is used without a namespace — in a multi-tenant/sharded
+app this shares one tenant's chunks (text included) with every other tenant, since
+Vectorize indexes are account-global. Pass \`namespace\` (the shard/tenant key) on both
+index() and retrieve(). Single-tenant apps suppress this via { allowSharedNamespace: true }.`
+  );
+};
+const assembleContext = (chunks) => chunks.map((chunk) => `[source:${chunk.sourceId}#${String(chunk.chunkIndex)}]
+${chunk.text}`).join("\n\n");
+const resolveEmbeddingModel = (input, ai) => {
+  if (typeof input === "object") {
+    return input;
+  }
+  if (ai === void 0) {
+    throw new LunoraError(
+      "INTERNAL",
+      "@lunora/ai/rag: `embeddingModel` is a Workers AI model id (or omitted) but the bound context has no `ai` (env.AI). Pass an AI SDK EmbeddingModel object to embed without Workers AI, or bind a context whose `ctx.ai` is wired."
+    );
+  }
+  return ai.embeddingModel(input);
+};
+const defineRag = (config) => {
+  if (typeof config.index !== "string" || config.index.length === 0) {
+    throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `index` must be a non-empty Vectorize index name");
+  }
+  const chunkSize = config.chunkSize ?? DEFAULT_CHUNK_SIZE;
+  const chunkOverlap = config.chunkOverlap ?? DEFAULT_CHUNK_OVERLAP;
+  if (!Number.isInteger(chunkSize) || chunkSize < 1) {
+    throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `chunkSize` must be a positive integer");
+  }
+  if (!Number.isInteger(chunkOverlap) || chunkOverlap < 0 || chunkOverlap >= chunkSize) {
+    throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `chunkOverlap` must be a non-negative integer smaller than `chunkSize`");
+  }
+  const defaultTopK = config.topK ?? DEFAULT_TOP_K;
+  if (!Number.isInteger(defaultTopK) || defaultTopK < 1) {
+    throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `topK` must be a positive integer");
+  }
+  if (config.embeddingModelVersion !== void 0 && !MODEL_VERSION_PATTERN.test(config.embeddingModelVersion)) {
+    throw new LunoraError(
+      "BAD_REQUEST",
+      '@lunora/ai/rag: `embeddingModelVersion` must match /^[A-Za-z0-9._-]{1,40}$/ (a short, stable tag like "bge-v1.5")'
+    );
+  }
+  const splitter = config.chunk ?? ((text) => fixedWindowChunks(text, chunkSize, chunkOverlap));
+  const { textStore } = config;
+  const topKCeiling = textStore ? MAX_TOP_K : MAX_TOP_K_FULL_METADATA;
+  const modelTag = config.embeddingModelVersion;
+  const withModelTag = (namespace) => {
+    if (modelTag === void 0) {
+      return namespace;
+    }
+    return namespace === void 0 ? modelTag : `${modelTag}::${namespace}`;
+  };
+  return (context) => {
+    let model;
+    const embedText = async (text) => {
+      model ??= resolveEmbeddingModel(config.embeddingModel, context.ai);
+      const { embedding } = await embed({ model, value: text });
+      return embedding;
+    };
+    const checkNamespace = (namespace) => {
+      if (namespace !== void 0) {
+        return;
+      }
+      if (config.requireNamespace) {
+        throw new LunoraError(
+          "BAD_REQUEST",
+          `@lunora/ai/rag: index "${config.index}" requires a namespace (requireNamespace is set) — pass the tenant/shard key on index()/retrieve()/remove()`
+        );
+      }
+      if (!config.allowSharedNamespace) {
+        warnSharedNamespace(config.index);
+      }
+    };
+    const readHead = async (sourceId, namespace) => {
+      const [head] = await context.vectors.getByIds(config.index, [chunkVectorId(namespace, sourceId, 0)], namespace);
+      const hash = head?.metadata?.[HASH_KEY];
+      const chunks = head?.metadata?.[COUNT_KEY];
+      return {
+        chunks: typeof chunks === "number" && Number.isInteger(chunks) && chunks > 0 ? chunks : void 0,
+        hash: typeof hash === "string" ? hash : void 0
+      };
+    };
+    const deleteChunkRange = async (sourceId, from, to, namespace) => {
+      const ids = Array.from({ length: to - from }, (_, offset) => chunkVectorId(namespace, sourceId, from + offset));
+      if (ids.length === 0) {
+        return;
+      }
+      await context.vectors.deleteByIds(config.index, ids, namespace);
+      await textStore?.remove?.(ids, { namespace });
+      await config.lexicalStore?.remove?.(ids, { namespace });
+    };
+    const index = async (input) => {
+      checkNamespace(input.namespace);
+      if (input.importance !== void 0 && (typeof input.importance !== "number" || input.importance < 0 || input.importance > 1)) {
+        throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `importance` must be a number in [0, 1]");
+      }
+      const effectiveNamespace = withModelTag(input.namespace);
+      const hash = await sha256Hex(input.text);
+      const previous = await readHead(input.id, effectiveNamespace);
+      if (previous.hash === hash && previous.chunks !== void 0) {
+        return {
+          chunks: previous.chunks,
+          ids: Array.from({ length: previous.chunks }, (_, chunkIndex) => chunkVectorId(effectiveNamespace, input.id, chunkIndex)),
+          unchanged: true
+        };
+      }
+      const pieces = splitter(input.text);
+      const ids = pieces.map((_, chunkIndex) => chunkVectorId(effectiveNamespace, input.id, chunkIndex));
+      if (pieces.length === 0 && input.allowEmptySources === false) {
+        throw new LunoraError("BAD_REQUEST", `@lunora/ai/rag: source "${input.id}" produced zero chunks — set allowEmptySources: true to allow this`);
+      }
+      if (pieces.length > 0) {
+        const storedChunks = pieces.map((text, chunkIndex) => {
+          return { chunkIndex, id: ids[chunkIndex], sourceId: input.id, text };
+        });
+        if (textStore) {
+          await textStore.put(storedChunks, { namespace: effectiveNamespace });
+        }
+        if (config.lexicalStore) {
+          await config.lexicalStore.index(storedChunks, { namespace: effectiveNamespace });
+        }
+      }
+      await concurrentMap(pieces, INDEX_CONCURRENCY, async (piece, chunkIndex) => {
+        const id = ids[chunkIndex];
+        const metadata = {
+          ...input.metadata,
+          [CHUNK_INDEX_KEY]: chunkIndex,
+          [SOURCE_KEY]: input.id
+        };
+        if (!textStore) {
+          metadata[TEXT_KEY] = piece;
+        }
+        if (input.importance !== void 0) {
+          metadata[IMPORTANCE_KEY] = input.importance;
+        }
+        if (chunkIndex === 0) {
+          metadata[HASH_KEY] = hash;
+          metadata[COUNT_KEY] = pieces.length;
+          if (modelTag !== void 0) {
+            metadata[MODEL_KEY] = modelTag;
+          }
+        }
+        await context.vectors.upsert(config.index, {
+          embed: embedText,
+          id,
+          input: piece,
+          metadata,
+          namespace: effectiveNamespace
+        });
+        input.onChunk?.({ chunkIndex, id, text: piece, total: pieces.length });
+      });
+      if (previous.chunks !== void 0 && previous.chunks > pieces.length) {
+        await deleteChunkRange(input.id, pieces.length, previous.chunks, effectiveNamespace);
+      }
+      return { chunks: pieces.length, ids, unchanged: false };
+    };
+    const remove = async (input) => {
+      checkNamespace(input.namespace);
+      const effectiveNamespace = withModelTag(input.namespace);
+      const previous = await readHead(input.id, effectiveNamespace);
+      const totalChunks = previous.chunks ?? 1;
+      await deleteChunkRange(input.id, 0, totalChunks, effectiveNamespace);
+    };
+    const textsByIds = async (ids, namespace) => {
+      const texts = /* @__PURE__ */ new Map();
+      if (ids.length === 0) {
+        return texts;
+      }
+      if (textStore) {
+        const stored = await textStore.getMany(ids, { namespace });
+        for (const [position, id] of ids.entries()) {
+          const text = stored[position];
+          if (typeof text === "string") {
+            texts.set(id, text);
+          }
+        }
+        return texts;
+      }
+      const records = await context.vectors.getByIds(config.index, ids, namespace);
+      for (const record of records) {
+        const text = record.metadata?.[TEXT_KEY];
+        if (typeof text === "string") {
+          texts.set(record.id, text);
+        }
+      }
+      return texts;
+    };
+    const expandChunks = async (chunks, options, effectiveNamespace) => {
+      const before = options?.chunkContext?.before ?? 0;
+      const after = options?.chunkContext?.after ?? 0;
+      if (before === 0 && after === 0) {
+        return chunks;
+      }
+      if (!Number.isInteger(before) || before < 0 || !Number.isInteger(after) || after < 0) {
+        throw new LunoraError("BAD_REQUEST", "@lunora/ai/rag: `chunkContext.before`/`chunkContext.after` must be non-negative integers");
+      }
+      const known = new Map(chunks.map((chunk) => [chunk.id, chunk.text]));
+      const neighbourIds = /* @__PURE__ */ new Set();
+      for (const chunk of chunks) {
+        for (let offset = -before; offset <= after; offset += 1) {
+          const neighbourIndex = chunk.chunkIndex + offset;
+          const id = chunkVectorId(effectiveNamespace, chunk.sourceId, neighbourIndex);
+          if (offset !== 0 && neighbourIndex >= 0 && !known.has(id)) {
+            neighbourIds.add(id);
+          }
+        }
+      }
+      const neighbourTexts = await textsByIds([...neighbourIds], effectiveNamespace);
+      const textOf = (sourceId, chunkIndex) => {
+        const id = chunkVectorId(effectiveNamespace, sourceId, chunkIndex);
+        return known.get(id) ?? neighbourTexts.get(id);
+      };
+      return chunks.map((chunk) => {
+        const parts = [];
+        for (let offset = -before; offset <= after; offset += 1) {
+          const text = offset === 0 ? chunk.text : textOf(chunk.sourceId, chunk.chunkIndex + offset);
+          if (text !== void 0) {
+            parts.push(text);
+          }
+        }
+        return { ...chunk, text: parts.join("\n") };
+      });
+    };
+    const resolveFilter = (filter) => {
+      if (typeof filter === "string") {
+        const resolved = config.filters?.[filter];
+        if (!resolved) {
+          throw new LunoraError(
+            "NOT_FOUND",
+            `@lunora/ai/rag: unknown named filter "${filter}" — must be one of the keys declared in RagConfig.filters`
+          );
+        }
+        return resolved.filter;
+      }
+      return filter;
+    };
+    const parseMatches = (result, namespace) => result.matches.map((match) => {
+      const metadata = match.metadata ?? {};
+      const parsed = parseChunkVectorId(match.id, namespace);
+      const rawText = metadata[TEXT_KEY];
+      const rawImportance = metadata[IMPORTANCE_KEY];
+      const importance = typeof rawImportance === "number" && rawImportance >= 0 && rawImportance <= 1 ? rawImportance : 1;
+      return {
+        chunkIndex: parsed.chunkIndex,
+        id: match.id,
+        importance,
+        metadata: userMetadataOf(metadata),
+        score: match.score * importance,
+        sourceId: parsed.sourceId,
+        text: typeof rawText === "string" ? rawText : ""
+      };
+    });
+    const hydrateFromStore = async (chunks, namespace) => {
+      if (!textStore) {
+        return chunks;
+      }
+      const texts = await textsByIds(
+        chunks.map((chunk) => chunk.id),
+        namespace
+      );
+      return chunks.flatMap((chunk) => {
+        const text = texts.get(chunk.id);
+        return text === void 0 ? [] : [{ ...chunk, text }];
+      });
+    };
+    const retrieve = async (query, options) => {
+      checkNamespace(options?.namespace);
+      const effectiveNamespace = withModelTag(options?.namespace);
+      const resolvedFilter = resolveFilter(options?.filter);
+      const rlsFilter = config.rlsFilter ? await config.rlsFilter(context.auth) : void 0;
+      const effectiveFilter = rlsFilter ? { ...resolvedFilter, ...rlsFilter } : resolvedFilter;
+      const topK = Math.min(options?.topK ?? defaultTopK, topKCeiling);
+      const vectorResult = await context.vectors.query(config.index, {
+        embed: embedText,
+        filter: effectiveFilter,
+        input: query,
+        namespace: effectiveNamespace,
+        returnMetadata: textStore ? "indexed" : "all",
+        topK
+      });
+      let chunks = await hydrateFromStore(parseMatches(vectorResult, effectiveNamespace), effectiveNamespace);
+      if (config.lexicalStore) {
+        const lexicalMatches = await config.lexicalStore.search(query, {
+          filter: effectiveFilter,
+          namespace: effectiveNamespace,
+          topK: config.lexicalTopK ?? topK
+        });
+        const lexicalChunks = lexicalMatches.map((match) => {
+          const parsed = parseChunkVectorId(match.id, effectiveNamespace);
+          return {
+            chunkIndex: parsed.chunkIndex,
+            id: match.id,
+            importance: 1,
+            metadata: void 0,
+            score: match.score,
+            sourceId: parsed.sourceId,
+            text: match.text
+          };
+        });
+        chunks = [...hybridRank(chunks, lexicalChunks)];
+      }
+      chunks.sort((a, b) => b.score - a.score);
+      const minScore = options?.minScore;
+      if (minScore !== void 0) {
+        chunks = chunks.filter((chunk) => chunk.score >= minScore);
+      }
+      chunks = [...await expandChunks(chunks, options, effectiveNamespace)];
+      const sources = [];
+      const seen = /* @__PURE__ */ new Set();
+      for (const chunk of chunks) {
+        if (!seen.has(chunk.sourceId)) {
+          seen.add(chunk.sourceId);
+          sources.push({ id: chunk.sourceId, metadata: chunk.metadata, weight: chunk.importance });
+        }
+      }
+      options?.onRetrieve?.({ matches: chunks.length, query });
+      return { chunks, context: assembleContext(chunks), sources };
+    };
+    const asTool = (options) => tool({
+      description: options?.description ?? `Search the "${config.index}" knowledge base for passages relevant to a natural-language query.`,
+      execute: async ({ query }) => retrieve(query, { namespace: options?.namespace, topK: options?.topK }),
+      inputSchema: jsonSchema({
+        properties: {
+          query: { description: "The natural-language search query.", type: "string" }
+        },
+        required: ["query"],
+        type: "object"
+      })
+    });
+    return { asTool, index, remove, retrieve };
+  };
+};
+
+export { defineRag as default };

package/dist/packem_shared/fixedWindowChunks-J-WfQDw9.mjs

@@ -0,0 +1,26 @@
+const fixedWindowChunks = (text, size, overlap) => {
+  if (!Number.isInteger(size) || size < 1) {
+    throw new RangeError("fixedWindowChunks: `size` must be a positive integer");
+  }
+  if (!Number.isInteger(overlap) || overlap < 0 || overlap >= size) {
+    throw new RangeError("fixedWindowChunks: `overlap` must be a non-negative integer smaller than `size`");
+  }
+  const trimmed = text.trim();
+  if (trimmed.length === 0) {
+    return [];
+  }
+  if (trimmed.length <= size) {
+    return [trimmed];
+  }
+  const step = Math.max(1, size - overlap);
+  const chunks = [];
+  for (let start = 0; start < trimmed.length; start += step) {
+    chunks.push(trimmed.slice(start, start + size));
+    if (start + size >= trimmed.length) {
+      break;
+    }
+  }
+  return chunks;
+};
+
+export { fixedWindowChunks as default };

package/dist/packem_shared/hybridRank-DPC9c2ON.mjs

@@ -0,0 +1,20 @@
+const hybridRank = (vectorResults, textResults, k = 60) => {
+  const fused = /* @__PURE__ */ new Map();
+  for (const [rank, chunk] of vectorResults.entries()) {
+    fused.set(chunk.id, { chunk, score: 1 / (k + rank), vectorRank: rank });
+  }
+  for (const [rank, chunk] of textResults.entries()) {
+    const existing = fused.get(chunk.id);
+    if (existing) {
+      existing.score += 1 / (k + rank);
+    } else {
+      fused.set(chunk.id, { chunk, score: 1 / (k + rank), vectorRank: Number.POSITIVE_INFINITY });
+    }
+  }
+  return [...fused.values()].toSorted((a, b) => {
+    const delta = b.score - a.score;
+    return delta === 0 ? a.vectorRank - b.vectorRank : delta;
+  }).map((entry) => entry.chunk);
+};
+
+export { hybridRank as default };

package/dist/packem_shared/types.d-C6dA8LCy.d.mts

@@ -0,0 +1,28 @@
+import { EmbeddingModel, LanguageModel } from 'ai';
+interface AiBindingLike {
+  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+}
+interface WorkersAiProviderLike {
+  (modelId: string, settings?: Record<string, unknown>): LanguageModel;
+  textEmbeddingModel?: (modelId: string) => EmbeddingModel;
+}
+interface AiGatewayOptions {
+  [key: string]: unknown;
+  id: string;
+}
+interface LunoraAiOptions {
+  binding?: AiBindingLike;
+  defaultEmbeddingModel?: string;
+  defaultModel?: string;
+  gateway?: AiGatewayOptions;
+  provider?: WorkersAiProviderLike;
+}
+type ModelInput = LanguageModel;
+type EmbeddingModelInput = EmbeddingModel | string;
+interface LunoraAi {
+  embeddingModel: (model?: EmbeddingModelInput) => EmbeddingModel;
+  model: (model?: ModelInput) => LanguageModel;
+  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+  workersai: WorkersAiProviderLike;
+}
+export { AiBindingLike as A, EmbeddingModelInput as E, LunoraAiOptions as L, ModelInput as M, WorkersAiProviderLike as W, LunoraAi as a, AiGatewayOptions as b };

package/dist/packem_shared/types.d-C6dA8LCy.d.ts

@@ -0,0 +1,28 @@
+import { EmbeddingModel, LanguageModel } from 'ai';
+interface AiBindingLike {
+  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+}
+interface WorkersAiProviderLike {
+  (modelId: string, settings?: Record<string, unknown>): LanguageModel;
+  textEmbeddingModel?: (modelId: string) => EmbeddingModel;
+}
+interface AiGatewayOptions {
+  [key: string]: unknown;
+  id: string;
+}
+interface LunoraAiOptions {
+  binding?: AiBindingLike;
+  defaultEmbeddingModel?: string;
+  defaultModel?: string;
+  gateway?: AiGatewayOptions;
+  provider?: WorkersAiProviderLike;
+}
+type ModelInput = LanguageModel;
+type EmbeddingModelInput = EmbeddingModel | string;
+interface LunoraAi {
+  embeddingModel: (model?: EmbeddingModelInput) => EmbeddingModel;
+  model: (model?: ModelInput) => LanguageModel;
+  run: (model: string, inputs: Record<string, unknown>, options?: Record<string, unknown>) => Promise<unknown>;
+  workersai: WorkersAiProviderLike;
+}
+export { AiBindingLike as A, EmbeddingModelInput as E, LunoraAiOptions as L, ModelInput as M, WorkersAiProviderLike as W, LunoraAi as a, AiGatewayOptions as b };

package/dist/rag/index.d.mts

@@ -0,0 +1,173 @@
+import { Tool } from 'ai';
+import { E as EmbeddingModelInput, a as LunoraAi } from "../packem_shared/types.d-C6dA8LCy.mjs";
+declare const fixedWindowChunks: (text: string, size: number, overlap: number) => ReadonlyArray<string>;
+type RagEmbedder = (input: string) => Promise<ReadonlyArray<number>> | ReadonlyArray<number>;
+interface RagVectorMatch {
+  id: string;
+  metadata?: Record<string, unknown>;
+  score: number;
+}
+interface RagVectorMatches {
+  count: number;
+  matches: ReadonlyArray<RagVectorMatch>;
+}
+interface RagVectorQueryInput {
+  embed?: RagEmbedder;
+  filter?: Record<string, unknown>;
+  input?: string;
+  namespace?: string;
+  returnMetadata?: "all" | "indexed" | "none";
+  topK?: number;
+}
+interface RagVectorRecord {
+  id: string;
+  metadata?: Record<string, unknown>;
+}
+interface RagVectorUpsertInput {
+  embed?: RagEmbedder;
+  id: string;
+  input: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+}
+interface RagVectors {
+  deleteByIds: (indexName: string, ids: ReadonlyArray<string>, namespace?: string) => Promise<unknown>;
+  getByIds: (indexName: string, ids: ReadonlyArray<string>, namespace?: string) => Promise<ReadonlyArray<RagVectorRecord>>;
+  query: (indexName: string, input: RagVectorQueryInput) => Promise<RagVectorMatches>;
+  upsert: (indexName: string, input: RagVectorUpsertInput) => Promise<unknown>;
+}
+interface RagContext {
+  ai?: Pick<LunoraAi, "embeddingModel">;
+  auth?: unknown;
+  vectors: RagVectors;
+}
+interface RagTextStore {
+  getMany: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<ReadonlyArray<string | undefined>>;
+  put: (chunks: ReadonlyArray<StoredRagChunk>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  remove?: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+}
+interface StoredRagChunk {
+  chunkIndex: number;
+  id: string;
+  sourceId: string;
+  text: string;
+}
+interface LexicalMatch {
+  id: string;
+  score: number;
+  text: string;
+}
+interface RagLexicalStore {
+  index: (chunks: ReadonlyArray<StoredRagChunk>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  remove?: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  search: (query: string, options: {
+    filter?: Record<string, unknown>;
+    namespace?: string;
+    topK: number;
+  }) => Promise<ReadonlyArray<LexicalMatch>>;
+}
+interface RagNamedFilter {
+  description?: string;
+  filter: Record<string, unknown>;
+}
+interface RagConfig {
+  allowSharedNamespace?: boolean;
+  chunk?: (text: string) => ReadonlyArray<string>;
+  chunkOverlap?: number;
+  chunkSize?: number;
+  embeddingModel?: EmbeddingModelInput;
+  embeddingModelVersion?: string;
+  filters?: Record<string, RagNamedFilter>;
+  index: string;
+  lexicalStore?: RagLexicalStore;
+  lexicalTopK?: number;
+  requireNamespace?: boolean;
+  rlsFilter?: (auth: unknown) => Promise<Record<string, unknown> | undefined> | Record<string, unknown> | undefined;
+  textStore?: RagTextStore;
+  topK?: number;
+}
+interface IndexInput {
+  allowEmptySources?: boolean;
+  id: string;
+  importance?: number;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  onChunk?: (info: {
+    chunkIndex: number;
+    id: string;
+    text: string;
+    total: number;
+  }) => void;
+  text: string;
+}
+interface IndexResult {
+  chunks: number;
+  ids: ReadonlyArray<string>;
+  unchanged: boolean;
+}
+interface RemoveInput {
+  id: string;
+  namespace?: string;
+}
+interface RetrieveOptions {
+  chunkContext?: {
+    after?: number;
+    before?: number;
+  };
+  filter?: Record<string, unknown> | string;
+  minScore?: number;
+  namespace?: string;
+  onRetrieve?: (info: {
+    matches: number;
+    query: string;
+  }) => void;
+  topK?: number;
+}
+interface RetrievedChunk {
+  chunkIndex: number;
+  id: string;
+  importance: number;
+  metadata?: Record<string, unknown>;
+  score: number;
+  sourceId: string;
+  text: string;
+}
+interface RagSource {
+  id: string;
+  metadata?: Record<string, unknown>;
+  weight?: number;
+}
+interface RetrieveResult {
+  chunks: ReadonlyArray<RetrievedChunk>;
+  context: string;
+  sources: ReadonlyArray<RagSource>;
+}
+interface RagToolOptions {
+  description?: string;
+  namespace?: string;
+  topK?: number;
+}
+interface Rag {
+  asTool: (options?: RagToolOptions) => Tool<{
+    query: string;
+  }, RetrieveResult>;
+  index: (input: IndexInput) => Promise<IndexResult>;
+  remove: (input: RemoveInput) => Promise<void>;
+  retrieve: (query: string, options?: RetrieveOptions) => Promise<RetrieveResult>;
+}
+declare const defineRag: (config: RagConfig) => ((context: RagContext) => Rag);
+declare const guessMimeTypeFromExtension: (extension: string) => string;
+declare const contentHash: (data: BufferSource) => Promise<string>;
+declare const hybridRank: (vectorResults: ReadonlyArray<RetrievedChunk>, textResults: ReadonlyArray<RetrievedChunk>, k?: number) => ReadonlyArray<RetrievedChunk>;
+declare const bm25LexicalStore: () => RagLexicalStore;
+export { type IndexInput, type IndexResult, type LexicalMatch, type Rag, type RagConfig, type RagContext, type RagEmbedder, type RagLexicalStore, type RagNamedFilter, type RagSource, type RagTextStore, type RagToolOptions, type RagVectorMatch, type RagVectorMatches, type RagVectorQueryInput, type RagVectorRecord, type RagVectorUpsertInput, type RagVectors, type RemoveInput, type RetrieveOptions, type RetrieveResult, type RetrievedChunk, type StoredRagChunk, bm25LexicalStore, contentHash, defineRag, fixedWindowChunks, guessMimeTypeFromExtension, hybridRank };

package/dist/rag/index.d.ts

@@ -0,0 +1,173 @@
+import { Tool } from 'ai';
+import { E as EmbeddingModelInput, a as LunoraAi } from "../packem_shared/types.d-C6dA8LCy.js";
+declare const fixedWindowChunks: (text: string, size: number, overlap: number) => ReadonlyArray<string>;
+type RagEmbedder = (input: string) => Promise<ReadonlyArray<number>> | ReadonlyArray<number>;
+interface RagVectorMatch {
+  id: string;
+  metadata?: Record<string, unknown>;
+  score: number;
+}
+interface RagVectorMatches {
+  count: number;
+  matches: ReadonlyArray<RagVectorMatch>;
+}
+interface RagVectorQueryInput {
+  embed?: RagEmbedder;
+  filter?: Record<string, unknown>;
+  input?: string;
+  namespace?: string;
+  returnMetadata?: "all" | "indexed" | "none";
+  topK?: number;
+}
+interface RagVectorRecord {
+  id: string;
+  metadata?: Record<string, unknown>;
+}
+interface RagVectorUpsertInput {
+  embed?: RagEmbedder;
+  id: string;
+  input: string;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+}
+interface RagVectors {
+  deleteByIds: (indexName: string, ids: ReadonlyArray<string>, namespace?: string) => Promise<unknown>;
+  getByIds: (indexName: string, ids: ReadonlyArray<string>, namespace?: string) => Promise<ReadonlyArray<RagVectorRecord>>;
+  query: (indexName: string, input: RagVectorQueryInput) => Promise<RagVectorMatches>;
+  upsert: (indexName: string, input: RagVectorUpsertInput) => Promise<unknown>;
+}
+interface RagContext {
+  ai?: Pick<LunoraAi, "embeddingModel">;
+  auth?: unknown;
+  vectors: RagVectors;
+}
+interface RagTextStore {
+  getMany: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<ReadonlyArray<string | undefined>>;
+  put: (chunks: ReadonlyArray<StoredRagChunk>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  remove?: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+}
+interface StoredRagChunk {
+  chunkIndex: number;
+  id: string;
+  sourceId: string;
+  text: string;
+}
+interface LexicalMatch {
+  id: string;
+  score: number;
+  text: string;
+}
+interface RagLexicalStore {
+  index: (chunks: ReadonlyArray<StoredRagChunk>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  remove?: (ids: ReadonlyArray<string>, options: {
+    namespace?: string;
+  }) => Promise<void>;
+  search: (query: string, options: {
+    filter?: Record<string, unknown>;
+    namespace?: string;
+    topK: number;
+  }) => Promise<ReadonlyArray<LexicalMatch>>;
+}
+interface RagNamedFilter {
+  description?: string;
+  filter: Record<string, unknown>;
+}
+interface RagConfig {
+  allowSharedNamespace?: boolean;
+  chunk?: (text: string) => ReadonlyArray<string>;
+  chunkOverlap?: number;
+  chunkSize?: number;
+  embeddingModel?: EmbeddingModelInput;
+  embeddingModelVersion?: string;
+  filters?: Record<string, RagNamedFilter>;
+  index: string;
+  lexicalStore?: RagLexicalStore;
+  lexicalTopK?: number;
+  requireNamespace?: boolean;
+  rlsFilter?: (auth: unknown) => Promise<Record<string, unknown> | undefined> | Record<string, unknown> | undefined;
+  textStore?: RagTextStore;
+  topK?: number;
+}
+interface IndexInput {
+  allowEmptySources?: boolean;
+  id: string;
+  importance?: number;
+  metadata?: Record<string, unknown>;
+  namespace?: string;
+  onChunk?: (info: {
+    chunkIndex: number;
+    id: string;
+    text: string;
+    total: number;
+  }) => void;
+  text: string;
+}
+interface IndexResult {
+  chunks: number;
+  ids: ReadonlyArray<string>;
+  unchanged: boolean;
+}
+interface RemoveInput {
+  id: string;
+  namespace?: string;
+}
+interface RetrieveOptions {
+  chunkContext?: {
+    after?: number;
+    before?: number;
+  };
+  filter?: Record<string, unknown> | string;
+  minScore?: number;
+  namespace?: string;
+  onRetrieve?: (info: {
+    matches: number;
+    query: string;
+  }) => void;
+  topK?: number;
+}
+interface RetrievedChunk {
+  chunkIndex: number;
+  id: string;
+  importance: number;
+  metadata?: Record<string, unknown>;
+  score: number;
+  sourceId: string;
+  text: string;
+}
+interface RagSource {
+  id: string;
+  metadata?: Record<string, unknown>;
+  weight?: number;
+}
+interface RetrieveResult {
+  chunks: ReadonlyArray<RetrievedChunk>;
+  context: string;
+  sources: ReadonlyArray<RagSource>;
+}
+interface RagToolOptions {
+  description?: string;
+  namespace?: string;
+  topK?: number;
+}
+interface Rag {
+  asTool: (options?: RagToolOptions) => Tool<{
+    query: string;
+  }, RetrieveResult>;
+  index: (input: IndexInput) => Promise<IndexResult>;
+  remove: (input: RemoveInput) => Promise<void>;
+  retrieve: (query: string, options?: RetrieveOptions) => Promise<RetrieveResult>;
+}
+declare const defineRag: (config: RagConfig) => ((context: RagContext) => Rag);
+declare const guessMimeTypeFromExtension: (extension: string) => string;
+declare const contentHash: (data: BufferSource) => Promise<string>;
+declare const hybridRank: (vectorResults: ReadonlyArray<RetrievedChunk>, textResults: ReadonlyArray<RetrievedChunk>, k?: number) => ReadonlyArray<RetrievedChunk>;
+declare const bm25LexicalStore: () => RagLexicalStore;
+export { type IndexInput, type IndexResult, type LexicalMatch, type Rag, type RagConfig, type RagContext, type RagEmbedder, type RagLexicalStore, type RagNamedFilter, type RagSource, type RagTextStore, type RagToolOptions, type RagVectorMatch, type RagVectorMatches, type RagVectorQueryInput, type RagVectorRecord, type RagVectorUpsertInput, type RagVectors, type RemoveInput, type RetrieveOptions, type RetrieveResult, type RetrievedChunk, type StoredRagChunk, bm25LexicalStore, contentHash, defineRag, fixedWindowChunks, guessMimeTypeFromExtension, hybridRank };

package/dist/rag/index.mjs

@@ -0,0 +1,5 @@
+export { default as fixedWindowChunks } from '../packem_shared/fixedWindowChunks-J-WfQDw9.mjs';
+export { default as defineRag } from '../packem_shared/defineRag-BwrgePLE.mjs';
+export { contentHash, guessMimeTypeFromExtension } from '../packem_shared/contentHash-Cgz5KRGD.mjs';
+export { default as hybridRank } from '../packem_shared/hybridRank-DPC9c2ON.mjs';
+export { default as bm25LexicalStore } from '../packem_shared/bm25LexicalStore-Q28z6fbO.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/ai",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.14",
   "description": "Workers AI helper for Lunora: provider-agnostic AI SDK access from functions, Workers AI by default",
   "keywords": [
     "ai",
@@ -10,6 +10,8 @@
     "inference",
     "llm",
     "lunora",
+    "rag",
+    "retrieval",
     "workers",
     "workers-ai"
   ],
@@ -41,6 +43,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs"
     },
+    "./rag": {
+      "types": "./dist/rag/index.d.ts",
+      "import": "./dist/rag/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "publishConfig": {