@nixxie-cms/ai-rag 1.0.0

package/dist/nixxie-cms-ai-rag.esm.js

@@ -0,0 +1,2481 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { text, json, select, integer, timestamp } from '@nixxie-cms/core/fields';
+import { g } from '@nixxie-cms/core';
+
+const DEFAULTS = {
+  strategy: 'recursive',
+  chunkSize: 1200,
+  chunkOverlap: 200
+};
+
+/** Boundary separators tried in order, coarsest first (recursive strategy). */
+const SEPARATORS = ['\n\n', '\n', '. ', '! ', '? ', '; ', ', ', ' '];
+
+/**
+ * Split text into overlapping chunks. The recursive strategy prefers to cut on the
+ * coarsest natural boundary that keeps a chunk under `chunkSize`, falling back to finer
+ * boundaries (and finally a hard slice) so no chunk overruns the budget.
+ */
+function chunkText(text, config = {}) {
+  var _config$strategy, _config$chunkSize, _config$chunkOverlap;
+  const strategy = (_config$strategy = config.strategy) !== null && _config$strategy !== void 0 ? _config$strategy : DEFAULTS.strategy;
+  const size = Math.max(1, (_config$chunkSize = config.chunkSize) !== null && _config$chunkSize !== void 0 ? _config$chunkSize : DEFAULTS.chunkSize);
+  const overlap = Math.max(0, Math.min((_config$chunkOverlap = config.chunkOverlap) !== null && _config$chunkOverlap !== void 0 ? _config$chunkOverlap : DEFAULTS.chunkOverlap, size - 1));
+  const normalized = text.replace(/\r\n/g, '\n').trim();
+  if (!normalized) return [];
+  if (normalized.length <= size) return [normalized];
+  const units = strategy === 'sentence' ? splitSentences(normalized) : strategy === 'fixed' ? hardSlice(normalized, size) : recursiveSplit(normalized, size);
+  return packWithOverlap(units, size, overlap);
+}
+
+/** Greedily pack atomic units into chunks <= size, carrying `overlap` chars between them. */
+function packWithOverlap(units, size, overlap) {
+  const chunks = [];
+  let current = '';
+  for (const unit of units) {
+    if (current && current.length + unit.length + 1 > size) {
+      chunks.push(current.trim());
+      current = overlap > 0 ? current.slice(Math.max(0, current.length - overlap)) : '';
+    }
+    current = current ? `${current} ${unit}`.trim() : unit;
+    // A single oversized unit: hard-slice it.
+    while (current.length > size) {
+      chunks.push(current.slice(0, size).trim());
+      current = current.slice(size - overlap);
+    }
+  }
+  if (current.trim()) chunks.push(current.trim());
+  return chunks.filter(Boolean);
+}
+function recursiveSplit(text, size) {
+  if (text.length <= size) return [text];
+  for (const sep of SEPARATORS) {
+    if (!text.includes(sep)) continue;
+    const parts = text.split(sep).filter(Boolean);
+    if (parts.length < 2) continue;
+    return parts.flatMap(p => p.length > size ? recursiveSplit(p, size) : [p]);
+  }
+  return hardSlice(text, size);
+}
+function splitSentences(text) {
+  return text.split(/(?<=[.!?])\s+/).map(s => s.trim()).filter(Boolean);
+}
+function hardSlice(text, size) {
+  const out = [];
+  for (let i = 0; i < text.length; i += size) out.push(text.slice(i, i + size));
+  return out;
+}
+
+const DEFAULT_REFUSAL = "I don't have enough information in my knowledge base to answer that.";
+
+/** Resolve guard config against defaults. */
+function resolveGuard(config = {}) {
+  var _config$enabled, _config$refuseWhenNoC, _config$refusal, _config$requireCitati, _config$groundingChec, _config$refuseWhenUng, _config$allowModelKno;
+  const enabled = (_config$enabled = config.enabled) !== null && _config$enabled !== void 0 ? _config$enabled : true;
+  return {
+    enabled,
+    refuseWhenNoContext: enabled && ((_config$refuseWhenNoC = config.refuseWhenNoContext) !== null && _config$refuseWhenNoC !== void 0 ? _config$refuseWhenNoC : true),
+    refusal: (_config$refusal = config.refusal) !== null && _config$refusal !== void 0 ? _config$refusal : DEFAULT_REFUSAL,
+    requireCitations: enabled && ((_config$requireCitati = config.requireCitations) !== null && _config$requireCitati !== void 0 ? _config$requireCitati : true),
+    groundingCheck: enabled && ((_config$groundingChec = config.groundingCheck) !== null && _config$groundingChec !== void 0 ? _config$groundingChec : false),
+    groundingModel: config.groundingModel,
+    refuseWhenUngrounded: (_config$refuseWhenUng = config.refuseWhenUngrounded) !== null && _config$refuseWhenUng !== void 0 ? _config$refuseWhenUng : true,
+    allowModelKnowledge: (_config$allowModelKno = config.allowModelKnowledge) !== null && _config$allowModelKno !== void 0 ? _config$allowModelKno : false
+  };
+}
+/**
+ * Decide whether retrieval found enough relevant context to answer. When nothing clears the
+ * relevance bar and `refuseWhenNoContext` is on (and model knowledge isn't allowed), the
+ * assistant should refuse instead of guessing.
+ */
+function shouldRefuseForNoContext(chunks, guard, minScore) {
+  var _chunks$0$score, _chunks$;
+  if (!guard.refuseWhenNoContext || guard.allowModelKnowledge) return false;
+  const best = (_chunks$0$score = (_chunks$ = chunks[0]) === null || _chunks$ === void 0 ? void 0 : _chunks$.score) !== null && _chunks$0$score !== void 0 ? _chunks$0$score : 0;
+  return chunks.length === 0 || best < minScore;
+}
+
+/**
+ * Post-hoc grounding check: ask a (cheap) model whether the drafted answer is fully
+ * supported by the retrieved context. Returns whether it's grounded plus an optional reason.
+ * Best-effort — any failure is treated as "grounded" so the guard never hard-fails a request.
+ */
+async function checkGrounding(provider, answer, chunks, model) {
+  if (!answer.trim() || chunks.length === 0) return {
+    grounded: true
+  };
+  const context = chunks.map((c, i) => `[${i + 1}] ${c.content}`).join('\n\n').slice(0, 8000);
+  const system = 'You are a strict fact-checker. Decide if the ANSWER is fully supported by the CONTEXT. ' + 'Reply with a single JSON object: {"grounded": boolean, "reason": string}. ' + 'An answer that adds facts not present in the context is NOT grounded. A refusal or ' + '"I don\'t know" counts as grounded.';
+  try {
+    const res = await provider.generate([{
+      role: 'user',
+      content: `CONTEXT:\n${context}\n\nANSWER:\n${answer}`
+    }], {
+      system,
+      model,
+      temperature: 0,
+      maxTokens: 200
+    });
+    const match = res.text.match(/\{[\s\S]*\}/);
+    if (!match) return {
+      grounded: true
+    };
+    const parsed = JSON.parse(match[0]);
+    return {
+      grounded: parsed.grounded !== false,
+      reason: parsed.reason
+    };
+  } catch {
+    return {
+      grounded: true
+    };
+  }
+}
+
+const DEFAULT_MODEL$3 = 'claude-opus-4-8';
+function loadAnthropic() {
+  try {
+    var _require$default;
+    return (_require$default = require('@anthropic-ai/sdk').default) !== null && _require$default !== void 0 ? _require$default : require('@anthropic-ai/sdk');
+  } catch {
+    throw new Error('[@nixxie-cms/ai-rag] The Anthropic provider requires @anthropic-ai/sdk. Run: npm install @anthropic-ai/sdk');
+  }
+}
+
+/** Anthropic (Claude) generation provider with native streaming. */
+class AnthropicRagProvider {
+  constructor(config) {
+    var _config$model, _config$extra;
+    _defineProperty(this, "name", 'anthropic');
+    _defineProperty(this, "defaultModel", DEFAULT_MODEL$3);
+    if (!config.apiKey) throw new Error('[@nixxie-cms/ai-rag] Anthropic generation requires `apiKey`.');
+    const Anthropic = loadAnthropic();
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+    this.model = (_config$model = config.model) !== null && _config$model !== void 0 ? _config$model : DEFAULT_MODEL$3;
+    this.maxTokens = 1024;
+    this.extra = (_config$extra = config.extra) !== null && _config$extra !== void 0 ? _config$extra : {};
+  }
+  buildBody(messages, options) {
+    var _options$model, _options$maxTokens, _options$extra;
+    return {
+      model: (_options$model = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model !== void 0 ? _options$model : this.model,
+      max_tokens: (_options$maxTokens = options === null || options === void 0 ? void 0 : options.maxTokens) !== null && _options$maxTokens !== void 0 ? _options$maxTokens : this.maxTokens,
+      system: (options === null || options === void 0 ? void 0 : options.system) || undefined,
+      messages: messages.map(m => ({
+        role: m.role,
+        content: m.content
+      })),
+      ...((options === null || options === void 0 ? void 0 : options.temperature) !== undefined ? {
+        temperature: options.temperature
+      } : {}),
+      ...((options === null || options === void 0 ? void 0 : options.topP) !== undefined ? {
+        top_p: options.topP
+      } : {}),
+      ...this.extra,
+      ...((_options$extra = options === null || options === void 0 ? void 0 : options.extra) !== null && _options$extra !== void 0 ? _options$extra : {})
+    };
+  }
+  async generate(messages, options) {
+    var _res$content, _ref, _res$model, _res$usage, _res$usage2;
+    const res = await this.client.messages.create(this.buildBody(messages, options));
+    const text = ((_res$content = res.content) !== null && _res$content !== void 0 ? _res$content : []).filter(b => b.type === 'text').map(b => b.text).join('');
+    return {
+      text,
+      model: (_ref = (_res$model = res.model) !== null && _res$model !== void 0 ? _res$model : options === null || options === void 0 ? void 0 : options.model) !== null && _ref !== void 0 ? _ref : this.model,
+      usage: {
+        inputTokens: (_res$usage = res.usage) === null || _res$usage === void 0 ? void 0 : _res$usage.input_tokens,
+        outputTokens: (_res$usage2 = res.usage) === null || _res$usage2 === void 0 ? void 0 : _res$usage2.output_tokens
+      }
+    };
+  }
+  async *stream(messages, options) {
+    var _options$model2;
+    const stream = await this.client.messages.create({
+      ...this.buildBody(messages, options),
+      stream: true
+    });
+    let input = 0;
+    let output = 0;
+    for await (const event of stream) {
+      var _event$delta;
+      if (event.type === 'content_block_delta' && ((_event$delta = event.delta) === null || _event$delta === void 0 ? void 0 : _event$delta.type) === 'text_delta') {
+        yield {
+          delta: event.delta.text
+        };
+      } else if (event.type === 'message_start') {
+        var _event$message$usage$, _event$message;
+        input = (_event$message$usage$ = (_event$message = event.message) === null || _event$message === void 0 || (_event$message = _event$message.usage) === null || _event$message === void 0 ? void 0 : _event$message.input_tokens) !== null && _event$message$usage$ !== void 0 ? _event$message$usage$ : input;
+      } else if (event.type === 'message_delta') {
+        var _event$usage$output_t, _event$usage;
+        output = (_event$usage$output_t = (_event$usage = event.usage) === null || _event$usage === void 0 ? void 0 : _event$usage.output_tokens) !== null && _event$usage$output_t !== void 0 ? _event$usage$output_t : output;
+      }
+    }
+    yield {
+      done: true,
+      model: (_options$model2 = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model2 !== void 0 ? _options$model2 : this.model,
+      usage: {
+        inputTokens: input,
+        outputTokens: output
+      }
+    };
+  }
+}
+
+const DEFAULT_MODEL$2 = 'gemini-2.0-flash';
+const DEFAULT_EMBEDDING_MODEL$2 = 'text-embedding-004';
+const DEFAULT_BASE$1 = 'https://generativelanguage.googleapis.com/v1beta';
+
+/** Google Gemini provider over the public REST API — generation, streaming and embeddings. */
+class GeminiRagProvider {
+  constructor(config) {
+    var _config$model, _config$model2, _config$baseUrl, _config$extra;
+    _defineProperty(this, "name", 'gemini');
+    _defineProperty(this, "defaultModel", DEFAULT_MODEL$2);
+    if (!config.apiKey) throw new Error('[@nixxie-cms/ai-rag] Gemini requires `apiKey`.');
+    this.apiKey = config.apiKey;
+    this.model = (_config$model = config.model) !== null && _config$model !== void 0 ? _config$model : DEFAULT_MODEL$2;
+    this.embeddingModel = (_config$model2 = config.model) !== null && _config$model2 !== void 0 ? _config$model2 : DEFAULT_EMBEDDING_MODEL$2;
+    this.base = ((_config$baseUrl = config.baseUrl) !== null && _config$baseUrl !== void 0 ? _config$baseUrl : DEFAULT_BASE$1).replace(/\/$/, '');
+    this.extra = (_config$extra = config.extra) !== null && _config$extra !== void 0 ? _config$extra : {};
+  }
+  buildBody(messages, options) {
+    var _options$extra;
+    return {
+      contents: messages.map(m => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{
+          text: m.content
+        }]
+      })),
+      ...(options !== null && options !== void 0 && options.system ? {
+        systemInstruction: {
+          parts: [{
+            text: options.system
+          }]
+        }
+      } : {}),
+      generationConfig: {
+        ...((options === null || options === void 0 ? void 0 : options.temperature) !== undefined ? {
+          temperature: options.temperature
+        } : {}),
+        ...((options === null || options === void 0 ? void 0 : options.maxTokens) !== undefined ? {
+          maxOutputTokens: options.maxTokens
+        } : {}),
+        ...((options === null || options === void 0 ? void 0 : options.topP) !== undefined ? {
+          topP: options.topP
+        } : {})
+      },
+      ...this.extra,
+      ...((_options$extra = options === null || options === void 0 ? void 0 : options.extra) !== null && _options$extra !== void 0 ? _options$extra : {})
+    };
+  }
+  extractText(data) {
+    var _data$candidates$0$co, _data$candidates;
+    const parts = (_data$candidates$0$co = data === null || data === void 0 || (_data$candidates = data.candidates) === null || _data$candidates === void 0 || (_data$candidates = _data$candidates[0]) === null || _data$candidates === void 0 || (_data$candidates = _data$candidates.content) === null || _data$candidates === void 0 ? void 0 : _data$candidates.parts) !== null && _data$candidates$0$co !== void 0 ? _data$candidates$0$co : [];
+    return parts.map(p => {
+      var _p$text;
+      return (_p$text = p.text) !== null && _p$text !== void 0 ? _p$text : '';
+    }).join('');
+  }
+  async generate(messages, options) {
+    var _options$model, _data$usageMetadata, _data$usageMetadata2;
+    const model = (_options$model = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model !== void 0 ? _options$model : this.model;
+    const res = await fetch(`${this.base}/models/${model}:generateContent?key=${this.apiKey}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(this.buildBody(messages, options))
+    });
+    if (!res.ok) throw new Error(`[@nixxie-cms/ai-rag] Gemini generate failed (${res.status}): ${await res.text()}`);
+    const data = await res.json();
+    return {
+      text: this.extractText(data),
+      model,
+      usage: {
+        inputTokens: data === null || data === void 0 || (_data$usageMetadata = data.usageMetadata) === null || _data$usageMetadata === void 0 ? void 0 : _data$usageMetadata.promptTokenCount,
+        outputTokens: data === null || data === void 0 || (_data$usageMetadata2 = data.usageMetadata) === null || _data$usageMetadata2 === void 0 ? void 0 : _data$usageMetadata2.candidatesTokenCount
+      }
+    };
+  }
+  async *stream(messages, options) {
+    var _options$model2, _usage, _usage2;
+    const model = (_options$model2 = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model2 !== void 0 ? _options$model2 : this.model;
+    const res = await fetch(`${this.base}/models/${model}:streamGenerateContent?alt=sse&key=${this.apiKey}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(this.buildBody(messages, options))
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`[@nixxie-cms/ai-rag] Gemini stream failed (${res.status}): ${await res.text()}`);
+    }
+    let usage;
+    for await (const data of parseSseJson(res.body)) {
+      const text = this.extractText(data);
+      if (text) yield {
+        delta: text
+      };
+      if (data !== null && data !== void 0 && data.usageMetadata) usage = data.usageMetadata;
+    }
+    yield {
+      done: true,
+      model,
+      usage: {
+        inputTokens: (_usage = usage) === null || _usage === void 0 ? void 0 : _usage.promptTokenCount,
+        outputTokens: (_usage2 = usage) === null || _usage2 === void 0 ? void 0 : _usage2.candidatesTokenCount
+      }
+    };
+  }
+  async embed(texts, model) {
+    var _data$embeddings;
+    const m = model !== null && model !== void 0 ? model : this.embeddingModel;
+    const res = await fetch(`${this.base}/models/${m}:batchEmbedContents?key=${this.apiKey}`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        requests: texts.map(text => ({
+          model: `models/${m}`,
+          content: {
+            parts: [{
+              text
+            }]
+          }
+        }))
+      })
+    });
+    if (!res.ok) throw new Error(`[@nixxie-cms/ai-rag] Gemini embed failed (${res.status}): ${await res.text()}`);
+    const data = await res.json();
+    return ((_data$embeddings = data.embeddings) !== null && _data$embeddings !== void 0 ? _data$embeddings : []).map(e => e.values);
+  }
+}
+
+/** Parse a `text/event-stream` of JSON `data:` lines into objects. */
+async function* parseSseJson(body) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+  for await (const piece of body) {
+    buffer += typeof piece === 'string' ? piece : decoder.decode(piece, {
+      stream: true
+    });
+    let idx;
+    while ((idx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line.startsWith('data:')) continue;
+      const payload = line.slice(5).trim();
+      if (!payload || payload === '[DONE]') continue;
+      try {
+        yield JSON.parse(payload);
+      } catch {
+        // Partial frame — ignore; the next chunk will complete it.
+      }
+    }
+  }
+}
+
+const DEFAULT_MODEL$1 = 'llama3.1';
+const DEFAULT_EMBEDDING_MODEL$1 = 'nomic-embed-text';
+const DEFAULT_BASE = 'http://localhost:11434';
+
+/**
+ * Ollama provider for local (or remote) open models — generation, streaming and embeddings.
+ * Runs any Ollama model family (Llama, Mistral, Phi, Gemma, Qwen, …). No API key needed for a
+ * local server; point `baseUrl` at your Ollama host if it isn't on localhost.
+ */
+class OllamaRagProvider {
+  constructor(config) {
+    var _config$baseUrl, _config$model, _config$model2, _config$extra;
+    _defineProperty(this, "name", 'ollama');
+    _defineProperty(this, "defaultModel", DEFAULT_MODEL$1);
+    this.base = ((_config$baseUrl = config.baseUrl) !== null && _config$baseUrl !== void 0 ? _config$baseUrl : DEFAULT_BASE).replace(/\/$/, '');
+    this.model = (_config$model = config.model) !== null && _config$model !== void 0 ? _config$model : DEFAULT_MODEL$1;
+    this.embeddingModel = (_config$model2 = config.model) !== null && _config$model2 !== void 0 ? _config$model2 : DEFAULT_EMBEDDING_MODEL$1;
+    this.apiKey = config.apiKey;
+    this.extra = (_config$extra = config.extra) !== null && _config$extra !== void 0 ? _config$extra : {};
+  }
+  headers() {
+    return {
+      'Content-Type': 'application/json',
+      ...(this.apiKey ? {
+        Authorization: `Bearer ${this.apiKey}`
+      } : {})
+    };
+  }
+  buildBody(messages, options, stream) {
+    var _options$model, _options$extra;
+    return {
+      model: (_options$model = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model !== void 0 ? _options$model : this.model,
+      stream,
+      messages: [...(options !== null && options !== void 0 && options.system ? [{
+        role: 'system',
+        content: options.system
+      }] : []), ...messages.map(m => ({
+        role: m.role,
+        content: m.content
+      }))],
+      options: {
+        ...((options === null || options === void 0 ? void 0 : options.temperature) !== undefined ? {
+          temperature: options.temperature
+        } : {}),
+        ...((options === null || options === void 0 ? void 0 : options.maxTokens) !== undefined ? {
+          num_predict: options.maxTokens
+        } : {}),
+        ...((options === null || options === void 0 ? void 0 : options.topP) !== undefined ? {
+          top_p: options.topP
+        } : {})
+      },
+      ...this.extra,
+      ...((_options$extra = options === null || options === void 0 ? void 0 : options.extra) !== null && _options$extra !== void 0 ? _options$extra : {})
+    };
+  }
+  async generate(messages, options) {
+    var _data$message$content, _data$message, _ref, _data$model;
+    const res = await fetch(`${this.base}/api/chat`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify(this.buildBody(messages, options, false))
+    });
+    if (!res.ok) throw new Error(`[@nixxie-cms/ai-rag] Ollama generate failed (${res.status}): ${await res.text()}`);
+    const data = await res.json();
+    return {
+      text: (_data$message$content = data === null || data === void 0 || (_data$message = data.message) === null || _data$message === void 0 ? void 0 : _data$message.content) !== null && _data$message$content !== void 0 ? _data$message$content : '',
+      model: (_ref = (_data$model = data === null || data === void 0 ? void 0 : data.model) !== null && _data$model !== void 0 ? _data$model : options === null || options === void 0 ? void 0 : options.model) !== null && _ref !== void 0 ? _ref : this.model,
+      usage: {
+        inputTokens: data === null || data === void 0 ? void 0 : data.prompt_eval_count,
+        outputTokens: data === null || data === void 0 ? void 0 : data.eval_count
+      }
+    };
+  }
+  async *stream(messages, options) {
+    var _options$model2, _usage, _usage2;
+    const res = await fetch(`${this.base}/api/chat`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify(this.buildBody(messages, options, true))
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`[@nixxie-cms/ai-rag] Ollama stream failed (${res.status}): ${await res.text()}`);
+    }
+    let usage;
+    // Ollama streams newline-delimited JSON objects.
+    for await (const obj of parseNdJson(res.body)) {
+      var _obj$message;
+      const delta = obj === null || obj === void 0 || (_obj$message = obj.message) === null || _obj$message === void 0 ? void 0 : _obj$message.content;
+      if (delta) yield {
+        delta
+      };
+      if (obj !== null && obj !== void 0 && obj.done) usage = obj;
+    }
+    yield {
+      done: true,
+      model: (_options$model2 = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model2 !== void 0 ? _options$model2 : this.model,
+      usage: {
+        inputTokens: (_usage = usage) === null || _usage === void 0 ? void 0 : _usage.prompt_eval_count,
+        outputTokens: (_usage2 = usage) === null || _usage2 === void 0 ? void 0 : _usage2.eval_count
+      }
+    };
+  }
+  async embed(texts, model) {
+    const m = model !== null && model !== void 0 ? model : this.embeddingModel;
+    // /api/embed accepts a batch; older servers only support /api/embeddings (single).
+    const res = await fetch(`${this.base}/api/embed`, {
+      method: 'POST',
+      headers: this.headers(),
+      body: JSON.stringify({
+        model: m,
+        input: texts
+      })
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (Array.isArray(data === null || data === void 0 ? void 0 : data.embeddings)) return data.embeddings;
+    }
+    // Fallback: one request per text against the legacy endpoint.
+    const out = [];
+    for (const text of texts) {
+      const r = await fetch(`${this.base}/api/embeddings`, {
+        method: 'POST',
+        headers: this.headers(),
+        body: JSON.stringify({
+          model: m,
+          prompt: text
+        })
+      });
+      if (!r.ok) throw new Error(`[@nixxie-cms/ai-rag] Ollama embed failed (${r.status}): ${await r.text()}`);
+      const d = await r.json();
+      out.push(d.embedding);
+    }
+    return out;
+  }
+}
+
+/** Parse newline-delimited JSON from a stream body. */
+async function* parseNdJson(body) {
+  const decoder = new TextDecoder();
+  let buffer = '';
+  for await (const piece of body) {
+    buffer += typeof piece === 'string' ? piece : decoder.decode(piece, {
+      stream: true
+    });
+    let idx;
+    while ((idx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, idx).trim();
+      buffer = buffer.slice(idx + 1);
+      if (!line) continue;
+      try {
+        yield JSON.parse(line);
+      } catch {
+        // Ignore partial lines.
+      }
+    }
+  }
+  const tail = buffer.trim();
+  if (tail) {
+    try {
+      yield JSON.parse(tail);
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+const DEFAULT_MODEL = 'gpt-4o';
+const DEFAULT_EMBEDDING_MODEL = 'text-embedding-3-small';
+function loadOpenAi() {
+  try {
+    var _require$default;
+    return (_require$default = require('openai').default) !== null && _require$default !== void 0 ? _require$default : require('openai');
+  } catch {
+    throw new Error('[@nixxie-cms/ai-rag] The OpenAI provider requires the openai package. Run: npm install openai');
+  }
+}
+
+/** OpenAI (GPT) provider — generation, streaming and embeddings. */
+class OpenAiRagProvider {
+  constructor(config) {
+    var _config$model, _config$model2, _config$extra;
+    _defineProperty(this, "name", 'openai');
+    _defineProperty(this, "defaultModel", DEFAULT_MODEL);
+    if (!config.apiKey) throw new Error('[@nixxie-cms/ai-rag] OpenAI requires `apiKey`.');
+    const OpenAI = loadOpenAi();
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl
+    });
+    this.model = (_config$model = config.model) !== null && _config$model !== void 0 ? _config$model : DEFAULT_MODEL;
+    this.embeddingModel = (_config$model2 = config.model) !== null && _config$model2 !== void 0 ? _config$model2 : DEFAULT_EMBEDDING_MODEL;
+    this.extra = (_config$extra = config.extra) !== null && _config$extra !== void 0 ? _config$extra : {};
+  }
+  buildMessages(messages, system) {
+    return [...(system ? [{
+      role: 'system',
+      content: system
+    }] : []), ...messages.map(m => ({
+      role: m.role,
+      content: m.content
+    }))];
+  }
+  async generate(messages, options) {
+    var _options$model, _options$extra, _res$choices$0$messag, _res$choices, _ref, _res$model, _res$usage, _res$usage2;
+    const res = await this.client.chat.completions.create({
+      model: (_options$model = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model !== void 0 ? _options$model : this.model,
+      messages: this.buildMessages(messages, options === null || options === void 0 ? void 0 : options.system),
+      ...((options === null || options === void 0 ? void 0 : options.maxTokens) !== undefined ? {
+        max_tokens: options.maxTokens
+      } : {}),
+      ...((options === null || options === void 0 ? void 0 : options.temperature) !== undefined ? {
+        temperature: options.temperature
+      } : {}),
+      ...((options === null || options === void 0 ? void 0 : options.topP) !== undefined ? {
+        top_p: options.topP
+      } : {}),
+      ...this.extra,
+      ...((_options$extra = options === null || options === void 0 ? void 0 : options.extra) !== null && _options$extra !== void 0 ? _options$extra : {})
+    });
+    return {
+      text: (_res$choices$0$messag = (_res$choices = res.choices) === null || _res$choices === void 0 || (_res$choices = _res$choices[0]) === null || _res$choices === void 0 || (_res$choices = _res$choices.message) === null || _res$choices === void 0 ? void 0 : _res$choices.content) !== null && _res$choices$0$messag !== void 0 ? _res$choices$0$messag : '',
+      model: (_ref = (_res$model = res.model) !== null && _res$model !== void 0 ? _res$model : options === null || options === void 0 ? void 0 : options.model) !== null && _ref !== void 0 ? _ref : this.model,
+      usage: {
+        inputTokens: (_res$usage = res.usage) === null || _res$usage === void 0 ? void 0 : _res$usage.prompt_tokens,
+        outputTokens: (_res$usage2 = res.usage) === null || _res$usage2 === void 0 ? void 0 : _res$usage2.completion_tokens
+      }
+    };
+  }
+  async *stream(messages, options) {
+    var _options$model2, _options$extra2, _options$model3, _usage, _usage2;
+    const stream = await this.client.chat.completions.create({
+      model: (_options$model2 = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model2 !== void 0 ? _options$model2 : this.model,
+      messages: this.buildMessages(messages, options === null || options === void 0 ? void 0 : options.system),
+      stream: true,
+      stream_options: {
+        include_usage: true
+      },
+      ...((options === null || options === void 0 ? void 0 : options.maxTokens) !== undefined ? {
+        max_tokens: options.maxTokens
+      } : {}),
+      ...((options === null || options === void 0 ? void 0 : options.temperature) !== undefined ? {
+        temperature: options.temperature
+      } : {}),
+      ...((options === null || options === void 0 ? void 0 : options.topP) !== undefined ? {
+        top_p: options.topP
+      } : {}),
+      ...this.extra,
+      ...((_options$extra2 = options === null || options === void 0 ? void 0 : options.extra) !== null && _options$extra2 !== void 0 ? _options$extra2 : {})
+    });
+    let usage;
+    for await (const part of stream) {
+      var _part$choices;
+      const delta = (_part$choices = part.choices) === null || _part$choices === void 0 || (_part$choices = _part$choices[0]) === null || _part$choices === void 0 || (_part$choices = _part$choices.delta) === null || _part$choices === void 0 ? void 0 : _part$choices.content;
+      if (delta) yield {
+        delta
+      };
+      if (part.usage) usage = part.usage;
+    }
+    yield {
+      done: true,
+      model: (_options$model3 = options === null || options === void 0 ? void 0 : options.model) !== null && _options$model3 !== void 0 ? _options$model3 : this.model,
+      usage: {
+        inputTokens: (_usage = usage) === null || _usage === void 0 ? void 0 : _usage.prompt_tokens,
+        outputTokens: (_usage2 = usage) === null || _usage2 === void 0 ? void 0 : _usage2.completion_tokens
+      }
+    };
+  }
+  async embed(texts, model) {
+    var _res$data;
+    const res = await this.client.embeddings.create({
+      model: model !== null && model !== void 0 ? model : this.embeddingModel,
+      input: texts
+    });
+    const items = (_res$data = res.data) !== null && _res$data !== void 0 ? _res$data : [];
+    return items.slice().sort((a, b) => {
+      var _a$index, _b$index;
+      return ((_a$index = a.index) !== null && _a$index !== void 0 ? _a$index : 0) - ((_b$index = b.index) !== null && _b$index !== void 0 ? _b$index : 0);
+    }).map(d => d.embedding);
+  }
+}
+
+/**
+ * Adapts an existing `NixxieAiService` (e.g. `context.services.ai` from @nixxie-cms/ai)
+ * into a RAG provider. Streaming is emulated by emitting the full answer as one delta,
+ * since `NixxieAiService` has no streaming surface.
+ */
+class ServiceRagProvider {
+  constructor(service) {
+    _defineProperty(this, "name", 'service');
+    _defineProperty(this, "defaultModel", 'service');
+    this.service = service;
+  }
+  async generate(messages, options) {
+    const res = await this.service.chat(messages, {
+      model: options === null || options === void 0 ? void 0 : options.model,
+      system: options === null || options === void 0 ? void 0 : options.system,
+      temperature: options === null || options === void 0 ? void 0 : options.temperature,
+      maxTokens: options === null || options === void 0 ? void 0 : options.maxTokens
+    });
+    return {
+      text: res.text,
+      model: res.model,
+      usage: res.usage
+    };
+  }
+  async *stream(messages, options) {
+    const res = await this.generate(messages, options);
+    if (res.text) yield {
+      delta: res.text
+    };
+    yield {
+      done: true,
+      model: res.model,
+      usage: res.usage
+    };
+  }
+  async embed(texts) {
+    return this.service.embedMany(texts);
+  }
+}
+
+/** Build the generation provider from config (default provider: anthropic). */
+function resolveGenerationProvider(config = {}) {
+  var _config$provider;
+  if (config.service) return new ServiceRagProvider(config.service);
+  const provider = (_config$provider = config.provider) !== null && _config$provider !== void 0 ? _config$provider : 'anthropic';
+  switch (provider) {
+    case 'anthropic':
+      return new AnthropicRagProvider(config);
+    case 'openai':
+      return new OpenAiRagProvider(config);
+    case 'gemini':
+      return new GeminiRagProvider(config);
+    case 'ollama':
+      return new OllamaRagProvider(config);
+    default:
+      {
+        const exhaustive = provider;
+        throw new Error(`[@nixxie-cms/ai-rag] Unknown generation provider: ${exhaustive}`);
+      }
+  }
+}
+
+/** Build the embedding provider from config (default provider: openai). */
+function resolveEmbeddingProvider(config = {}) {
+  var _config$provider2;
+  if (config.service) return new ServiceRagProvider(config.service);
+  const provider = (_config$provider2 = config.provider) !== null && _config$provider2 !== void 0 ? _config$provider2 : 'openai';
+  switch (provider) {
+    case 'openai':
+      return new OpenAiRagProvider(config);
+    case 'gemini':
+      return new GeminiRagProvider(config);
+    case 'ollama':
+      return new OllamaRagProvider(config);
+    case 'anthropic':
+      throw new Error('[@nixxie-cms/ai-rag] Anthropic has no native embeddings endpoint. Use `openai`, ' + '`gemini` or `ollama` for the `embedding` provider (you can still use Anthropic for generation).');
+    default:
+      {
+        const exhaustive = provider;
+        throw new Error(`[@nixxie-cms/ai-rag] Unknown embedding provider: ${exhaustive}`);
+      }
+  }
+}
+
+const DEFAULT_SYSTEM_PROMPT = 'You are a helpful assistant that answers questions strictly using the provided knowledge ' + 'base context. Be accurate and concise. If the context does not contain the answer, say you ' + "don't know rather than guessing.";
+const ALLOW_KNOWLEDGE_SYSTEM_PROMPT = 'You are a helpful assistant. Prefer the provided knowledge base context when answering. If ' + 'the context is insufficient you may use your general knowledge, but make clear which parts ' + 'are not from the knowledge base.';
+
+/** Render retrieved chunks as a numbered, citable source block. */
+function renderContext(chunks, maxChars) {
+  const lines = [];
+  let used = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    const c = chunks[i];
+    const header = `[${i + 1}]${c.title ? ` ${c.title}` : ''}${c.source ? ` (${c.source})` : ''}`;
+    const body = c.content.trim();
+    const block = `${header}\n${body}`;
+    if (used + block.length > maxChars && lines.length > 0) break;
+    lines.push(block);
+    used += block.length;
+  }
+  return lines.join('\n\n');
+}
+
+/**
+ * Default prompt assembly: a system prompt carrying the numbered context + citation rules,
+ * the trimmed history, and the user's question. Overridable via `generation.buildPrompt`.
+ */
+function buildRagPrompt(args, options) {
+  const contextBlock = renderContext(args.context, options.maxContextChars);
+  const rules = [];
+  if (args.context.length > 0) {
+    rules.push('Answer using ONLY the numbered context below.');
+    if (args.requireCitations) {
+      rules.push('Cite the sources you used inline as [n] matching the context numbers.');
+    }
+    rules.push("If the context does not contain the answer, say you don't have that information.");
+  }
+  const system = [args.systemPrompt, rules.length ? `\nRules:\n- ${rules.join('\n- ')}` : '', contextBlock ? `\nContext:\n${contextBlock}` : '\nContext: (none found)'].filter(Boolean).join('\n');
+  const messages = [...args.history, {
+    role: 'user',
+    content: args.question
+  }];
+  return {
+    system,
+    messages
+  };
+}
+
+/** A minimal counting semaphore used to cap concurrent generations. */
+class Semaphore {
+  constructor(permits) {
+    _defineProperty(this, "waiters", []);
+    this.available = Math.max(1, permits);
+  }
+
+  /** Acquire a permit, resolving to a `release` function to call when done. */
+  async acquire() {
+    if (this.available > 0) {
+      this.available--;
+      return () => this.release();
+    }
+    await new Promise(resolve => this.waiters.push(resolve));
+    this.available--;
+    return () => this.release();
+  }
+  release() {
+    this.available++;
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+}
+
+/** Dot product of two equal-length vectors. */
+function dot(a, b) {
+  let sum = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) sum += a[i] * b[i];
+  return sum;
+}
+
+/** Euclidean norm of a vector. */
+function norm(a) {
+  return Math.sqrt(dot(a, a));
+}
+
+/**
+ * Cosine similarity mapped from [-1, 1] into [0, 1] so it can be used as a relevance
+ * score and compared against a `minScore` threshold. Returns 0 for a zero vector.
+ */
+function cosineSimilarity(a, b) {
+  const denom = norm(a) * norm(b);
+  if (denom === 0) return 0;
+  const cos = dot(a, b) / denom;
+  // Clamp for floating-point drift, then rescale to [0, 1].
+  return (Math.max(-1, Math.min(1, cos)) + 1) / 2;
+}
+
+/** Pre-normalise a vector to unit length (lets retrieval use a plain dot product). */
+function normalize(a) {
+  const n = norm(a);
+  if (n === 0) return a.slice();
+  return a.map(x => x / n);
+}
+
+function prismaDelegate(context, listKey) {
+  var _context$prisma;
+  const delegate = (_context$prisma = context.prisma) === null || _context$prisma === void 0 ? void 0 : _context$prisma[listKey[0].toLowerCase() + listKey.slice(1)];
+  if (!delegate) {
+    throw new Error(`[@nixxie-cms/ai-rag] Collection "${listKey}" was not found in the Prisma client. ` + `Add it to your config (e.g. via \`ragPlugin()\` or \`knowledgeChunkCollection()\`) and run a migration.`);
+  }
+  return delegate;
+}
+function hasAllTags(recordTags, wanted) {
+  if (!wanted || wanted.length === 0) return true;
+  if (!recordTags || recordTags.length === 0) return false;
+  const set = new Set(recordTags);
+  return wanted.every(t => set.has(t));
+}
+function score(records, query) {
+  const scored = records.map(r => ({
+    ...r,
+    score: cosineSimilarity(query.embedding, r.embedding)
+  })).filter(r => hasAllTags(r.tags, query.tags)).filter(r => query.minScore === undefined ? true : r.score >= query.minScore);
+  scored.sort((a, b) => b.score - a.score);
+  return scored.slice(0, query.topK);
+}
+
+/**
+ * Default vector store: persists embeddings in the chunk collection in the host app's own
+ * database (any provider) and scores candidates with cosine similarity in Node. Simple and
+ * portable; for very large knowledge bases swap in a pgvector / external store via
+ * `retrieval.vectorStore`.
+ */
+class SqlVectorStore {
+  constructor(collection) {
+    _defineProperty(this, "model", null);
+    this.collection = collection;
+  }
+  init(context) {
+    this.model = prismaDelegate(context, this.collection);
+  }
+  requireModel() {
+    if (!this.model) {
+      throw new Error('[@nixxie-cms/ai-rag] The vector store is not ready yet — it becomes available once the database has connected.');
+    }
+    return this.model;
+  }
+  async upsert(documentId, records) {
+    const model = this.requireModel();
+    await model.deleteMany({
+      where: {
+        documentId
+      }
+    });
+    if (records.length === 0) return;
+    // createMany can't always return rows and ignores unsupported JSON on some providers,
+    // so insert sequentially for portability.
+    for (const r of records) {
+      var _r$title, _r$source, _r$tags, _r$metadata;
+      await model.create({
+        data: {
+          documentId,
+          content: r.content,
+          embedding: r.embedding,
+          title: (_r$title = r.title) !== null && _r$title !== void 0 ? _r$title : null,
+          source: (_r$source = r.source) !== null && _r$source !== void 0 ? _r$source : null,
+          tags: (_r$tags = r.tags) !== null && _r$tags !== void 0 ? _r$tags : [],
+          metadata: (_r$metadata = r.metadata) !== null && _r$metadata !== void 0 ? _r$metadata : null
+        }
+      });
+    }
+  }
+  async deleteByDocument(documentId) {
+    await this.requireModel().deleteMany({
+      where: {
+        documentId
+      }
+    });
+  }
+  async query(query) {
+    const rows = await this.requireModel().findMany();
+    const records = rows.map(rowToRecord);
+    return score(records, query);
+  }
+  async count() {
+    return this.requireModel().count();
+  }
+  async clear() {
+    await this.requireModel().deleteMany({});
+  }
+}
+function rowToRecord(row) {
+  var _row$content, _row$embedding, _row$title, _row$source, _ref;
+  return {
+    id: String(row.id),
+    documentId: String(row.documentId),
+    content: (_row$content = row.content) !== null && _row$content !== void 0 ? _row$content : '',
+    embedding: Array.isArray(row.embedding) ? row.embedding : (_row$embedding = row.embedding) !== null && _row$embedding !== void 0 ? _row$embedding : [],
+    title: (_row$title = row.title) !== null && _row$title !== void 0 ? _row$title : undefined,
+    source: (_row$source = row.source) !== null && _row$source !== void 0 ? _row$source : undefined,
+    tags: Array.isArray(row.tags) ? row.tags : undefined,
+    metadata: (_ref = row.metadata) !== null && _ref !== void 0 ? _ref : undefined
+  };
+}
+
+/** Ephemeral in-process vector store. Useful for tests and small/transient knowledge bases. */
+class InMemoryVectorStore {
+  constructor() {
+    _defineProperty(this, "byDocument", new Map());
+  }
+  async upsert(documentId, records) {
+    this.byDocument.set(documentId, records);
+  }
+  async deleteByDocument(documentId) {
+    this.byDocument.delete(documentId);
+  }
+  async query(query) {
+    const all = [];
+    for (const records of this.byDocument.values()) all.push(...records);
+    return score(all, query);
+  }
+  async count() {
+    let n = 0;
+    for (const records of this.byDocument.values()) n += records.length;
+    return n;
+  }
+  async clear() {
+    this.byDocument.clear();
+  }
+}
+
+function snippet(text, max = 240) {
+  const t = text.trim().replace(/\s+/g, ' ');
+  return t.length > max ? `${t.slice(0, max)}…` : t;
+}
+
+/** The main RAG assistant. Create via `createAiRag()`; register via `ragPlugin()`. */
+class AiRagService {
+  constructor(config = {}) {
+    var _config$collections$d, _config$collections, _config$collections$c, _config$collections2, _config$retrieval$vec, _config$retrieval, _config$retrieval2, _config$generation$te, _config$generation, _config$generation$ma, _config$generation2, _config$generation3, _config$generation4, _config$generation$sy, _config$generation5, _config$generation6, _config$embedding$bat, _config$embedding, _config$embedding2, _config$retrieval$top, _config$retrieval3, _config$retrieval$min, _config$retrieval4, _config$retrieval$max, _config$retrieval5, _config$retrieval$can, _config$retrieval6, _config$chunking$chun, _config$chunking, _config$chunking$chun2, _config$chunking2, _config$chunking$stra, _config$chunking3, _config$chat$historyL, _config$chat, _config$limits$maxQue, _config$limits, _config$indexing$auto, _config$indexing, _config$indexing$onCo, _config$indexing2, _config$indexing3, _config$indexing$conc, _config$indexing4, _config$limits$maxCon, _config$limits2;
+    _defineProperty(this, "documents", null);
+    const documentsCollection = (_config$collections$d = (_config$collections = config.collections) === null || _config$collections === void 0 ? void 0 : _config$collections.documents) !== null && _config$collections$d !== void 0 ? _config$collections$d : 'KnowledgeBase';
+    const chunksCollection = (_config$collections$c = (_config$collections2 = config.collections) === null || _config$collections2 === void 0 ? void 0 : _config$collections2.chunks) !== null && _config$collections$c !== void 0 ? _config$collections$c : 'KnowledgeChunk';
+    this.generation = resolveGenerationProvider(config.generation);
+    this.embedder = resolveEmbeddingProvider(config.embedding);
+    this.vectorStore = (_config$retrieval$vec = (_config$retrieval = config.retrieval) === null || _config$retrieval === void 0 ? void 0 : _config$retrieval.vectorStore) !== null && _config$retrieval$vec !== void 0 ? _config$retrieval$vec : new SqlVectorStore(chunksCollection);
+    this.rerank = (_config$retrieval2 = config.retrieval) === null || _config$retrieval2 === void 0 ? void 0 : _config$retrieval2.rerank;
+    const guard = resolveGuard(config.guard);
+    const defaultSystem = guard.allowModelKnowledge ? ALLOW_KNOWLEDGE_SYSTEM_PROMPT : DEFAULT_SYSTEM_PROMPT;
+    this.r = {
+      documentsCollection,
+      chunksCollection,
+      generation: {
+        temperature: (_config$generation$te = (_config$generation = config.generation) === null || _config$generation === void 0 ? void 0 : _config$generation.temperature) !== null && _config$generation$te !== void 0 ? _config$generation$te : 0.2,
+        maxTokens: (_config$generation$ma = (_config$generation2 = config.generation) === null || _config$generation2 === void 0 ? void 0 : _config$generation2.maxTokens) !== null && _config$generation$ma !== void 0 ? _config$generation$ma : 1024,
+        topP: (_config$generation3 = config.generation) === null || _config$generation3 === void 0 ? void 0 : _config$generation3.topP,
+        model: (_config$generation4 = config.generation) === null || _config$generation4 === void 0 ? void 0 : _config$generation4.model,
+        systemPrompt: (_config$generation$sy = (_config$generation5 = config.generation) === null || _config$generation5 === void 0 ? void 0 : _config$generation5.systemPrompt) !== null && _config$generation$sy !== void 0 ? _config$generation$sy : defaultSystem,
+        buildPrompt: (_config$generation6 = config.generation) === null || _config$generation6 === void 0 ? void 0 : _config$generation6.buildPrompt
+      },
+      embeddingBatchSize: (_config$embedding$bat = (_config$embedding = config.embedding) === null || _config$embedding === void 0 ? void 0 : _config$embedding.batchSize) !== null && _config$embedding$bat !== void 0 ? _config$embedding$bat : 64,
+      embeddingModel: (_config$embedding2 = config.embedding) === null || _config$embedding2 === void 0 ? void 0 : _config$embedding2.model,
+      topK: (_config$retrieval$top = (_config$retrieval3 = config.retrieval) === null || _config$retrieval3 === void 0 ? void 0 : _config$retrieval3.topK) !== null && _config$retrieval$top !== void 0 ? _config$retrieval$top : 5,
+      minScore: (_config$retrieval$min = (_config$retrieval4 = config.retrieval) === null || _config$retrieval4 === void 0 ? void 0 : _config$retrieval4.minScore) !== null && _config$retrieval$min !== void 0 ? _config$retrieval$min : 0.2,
+      maxContextChars: (_config$retrieval$max = (_config$retrieval5 = config.retrieval) === null || _config$retrieval5 === void 0 ? void 0 : _config$retrieval5.maxContextChars) !== null && _config$retrieval$max !== void 0 ? _config$retrieval$max : 6000,
+      candidateMultiplier: (_config$retrieval$can = (_config$retrieval6 = config.retrieval) === null || _config$retrieval6 === void 0 ? void 0 : _config$retrieval6.candidateMultiplier) !== null && _config$retrieval$can !== void 0 ? _config$retrieval$can : 4,
+      chunkSize: (_config$chunking$chun = (_config$chunking = config.chunking) === null || _config$chunking === void 0 ? void 0 : _config$chunking.chunkSize) !== null && _config$chunking$chun !== void 0 ? _config$chunking$chun : 1200,
+      chunkOverlap: (_config$chunking$chun2 = (_config$chunking2 = config.chunking) === null || _config$chunking2 === void 0 ? void 0 : _config$chunking2.chunkOverlap) !== null && _config$chunking$chun2 !== void 0 ? _config$chunking$chun2 : 200,
+      chunkStrategy: (_config$chunking$stra = (_config$chunking3 = config.chunking) === null || _config$chunking3 === void 0 ? void 0 : _config$chunking3.strategy) !== null && _config$chunking$stra !== void 0 ? _config$chunking$stra : 'recursive',
+      historyLimit: (_config$chat$historyL = (_config$chat = config.chat) === null || _config$chat === void 0 ? void 0 : _config$chat.historyLimit) !== null && _config$chat$historyL !== void 0 ? _config$chat$historyL : 10,
+      maxQueryChars: (_config$limits$maxQue = (_config$limits = config.limits) === null || _config$limits === void 0 ? void 0 : _config$limits.maxQueryChars) !== null && _config$limits$maxQue !== void 0 ? _config$limits$maxQue : 8000,
+      guard,
+      indexing: {
+        auto: (_config$indexing$auto = (_config$indexing = config.indexing) === null || _config$indexing === void 0 ? void 0 : _config$indexing.auto) !== null && _config$indexing$auto !== void 0 ? _config$indexing$auto : true,
+        onConnect: (_config$indexing$onCo = (_config$indexing2 = config.indexing) === null || _config$indexing2 === void 0 ? void 0 : _config$indexing2.onConnect) !== null && _config$indexing$onCo !== void 0 ? _config$indexing$onCo : true,
+        schedule: (_config$indexing3 = config.indexing) === null || _config$indexing3 === void 0 ? void 0 : _config$indexing3.schedule,
+        concurrency: (_config$indexing$conc = (_config$indexing4 = config.indexing) === null || _config$indexing4 === void 0 ? void 0 : _config$indexing4.concurrency) !== null && _config$indexing$conc !== void 0 ? _config$indexing$conc : 4
+      }
+    };
+    this.chatGate = new Semaphore((_config$limits$maxCon = (_config$limits2 = config.limits) === null || _config$limits2 === void 0 ? void 0 : _config$limits2.maxConcurrentChats) !== null && _config$limits$maxCon !== void 0 ? _config$limits$maxCon : 8);
+  }
+
+  /** Names of the collections this service reads/writes (used by the plugin). */
+  get collections() {
+    return {
+      documents: this.r.documentsCollection,
+      chunks: this.r.chunksCollection
+    };
+  }
+  get indexingSchedule() {
+    return this.r.indexing.schedule;
+  }
+
+  // ── Lifecycle ──
+
+  async init(context) {
+    var _this$vectorStore$ini, _this$vectorStore;
+    this.documents = this.requireDelegate(context, this.r.documentsCollection);
+    await ((_this$vectorStore$ini = (_this$vectorStore = this.vectorStore).init) === null || _this$vectorStore$ini === void 0 ? void 0 : _this$vectorStore$ini.call(_this$vectorStore, context));
+    if (this.r.indexing.onConnect) {
+      // Index anything still pending without blocking boot on failures.
+      this.indexPending().catch(err => console.error('[@nixxie-cms/ai-rag] Initial indexing failed:', err));
+    }
+  }
+  requireDelegate(context, listKey) {
+    var _context$prisma;
+    const delegate = (_context$prisma = context.prisma) === null || _context$prisma === void 0 ? void 0 : _context$prisma[listKey[0].toLowerCase() + listKey.slice(1)];
+    if (!delegate) {
+      throw new Error(`[@nixxie-cms/ai-rag] Collection "${listKey}" was not found in the Prisma client. ` + `Register it via \`ragPlugin()\` (or add \`${listKey}: knowledgeBaseCollection()\`) and run a migration.`);
+    }
+    return delegate;
+  }
+  requireDocuments() {
+    if (!this.documents) {
+      throw new Error('[@nixxie-cms/ai-rag] Not ready yet — the knowledge base is available once the database has connected.');
+    }
+    return this.documents;
+  }
+
+  // ── Knowledge-base content ──
+
+  async addDocument(doc) {
+    const [created] = await this.addDocuments([doc]);
+    return created;
+  }
+  async addDocuments(docs) {
+    const model = this.requireDocuments();
+    const out = [];
+    for (const doc of docs) {
+      var _doc$title, _doc$source, _doc$tags, _doc$metadata;
+      const row = await model.create({
+        data: {
+          title: (_doc$title = doc.title) !== null && _doc$title !== void 0 ? _doc$title : null,
+          content: doc.content,
+          source: (_doc$source = doc.source) !== null && _doc$source !== void 0 ? _doc$source : null,
+          tags: (_doc$tags = doc.tags) !== null && _doc$tags !== void 0 ? _doc$tags : [],
+          metadata: (_doc$metadata = doc.metadata) !== null && _doc$metadata !== void 0 ? _doc$metadata : null,
+          status: 'pending',
+          chunkCount: 0
+        }
+      });
+      out.push(rowToDocument(row));
+    }
+    if (this.r.indexing.auto) {
+      for (const d of out) {
+        try {
+          await this.index(d.id);
+        } catch (err) {
+          console.error(`[@nixxie-cms/ai-rag] Failed to index document ${d.id}:`, err);
+        }
+      }
+      // Re-read to reflect post-index status.
+      const refreshed = await Promise.all(out.map(d => this.getDocument(d.id)));
+      return refreshed.map((d, i) => d !== null && d !== void 0 ? d : out[i]);
+    }
+    return out;
+  }
+  async getDocument(id) {
+    const row = await this.requireDocuments().findUnique({
+      where: {
+        id
+      }
+    });
+    return row ? rowToDocument(row) : undefined;
+  }
+  async listDocuments(query = {}) {
+    var _query$skip;
+    const where = {};
+    if (query.status) where.status = {
+      equals: query.status
+    };
+    if (query.search) {
+      where.OR = [{
+        title: {
+          contains: query.search
+        }
+      }, {
+        content: {
+          contains: query.search
+        }
+      }, {
+        source: {
+          contains: query.search
+        }
+      }];
+    }
+    const rows = await this.requireDocuments().findMany({
+      where,
+      orderBy: {
+        createdAt: 'desc'
+      },
+      skip: (_query$skip = query.skip) !== null && _query$skip !== void 0 ? _query$skip : 0,
+      ...(query.take !== undefined ? {
+        take: query.take
+      } : {})
+    });
+    let docs = rows.map(rowToDocument);
+    // Tag filtering is done in Node for cross-database portability (tags are stored as JSON).
+    if (query.tags && query.tags.length) {
+      docs = docs.filter(d => query.tags.every(t => {
+        var _d$tags;
+        return ((_d$tags = d.tags) !== null && _d$tags !== void 0 ? _d$tags : []).includes(t);
+      }));
+    }
+    return docs;
+  }
+  async updateDocument(id, patch) {
+    const model = this.requireDocuments();
+    const data = {
+      status: 'pending'
+    };
+    if (patch.title !== undefined) data.title = patch.title;
+    if (patch.content !== undefined) data.content = patch.content;
+    if (patch.source !== undefined) data.source = patch.source;
+    if (patch.tags !== undefined) data.tags = patch.tags;
+    if (patch.metadata !== undefined) data.metadata = patch.metadata;
+    await model.update({
+      where: {
+        id
+      },
+      data
+    });
+    if (this.r.indexing.auto) {
+      try {
+        await this.index(id);
+      } catch (err) {
+        console.error(`[@nixxie-cms/ai-rag] Failed to re-index document ${id}:`, err);
+      }
+    }
+    const doc = await this.getDocument(id);
+    if (!doc) throw new Error(`[@nixxie-cms/ai-rag] Document not found after update: ${id}`);
+    return doc;
+  }
+  async removeDocument(id) {
+    await this.vectorStore.deleteByDocument(id);
+    await this.requireDocuments().delete({
+      where: {
+        id
+      }
+    });
+  }
+
+  /**
+   * Delete a document's indexed chunks without touching the document row. Used by the
+   * auto-index delete hook, where the KB row has already been removed by the CMS.
+   */
+  async purgeChunks(documentId) {
+    await this.vectorStore.deleteByDocument(documentId);
+  }
+
+  // ── Indexing ──
+
+  async index(documentId) {
+    const model = this.requireDocuments();
+    const row = await model.findUnique({
+      where: {
+        id: documentId
+      }
+    });
+    if (!row) throw new Error(`[@nixxie-cms/ai-rag] Document not found: ${documentId}`);
+    const doc = rowToDocument(row);
+    if (doc.status === 'disabled') {
+      await this.vectorStore.deleteByDocument(documentId);
+      await model.update({
+        where: {
+          id: documentId
+        },
+        data: {
+          chunkCount: 0
+        }
+      });
+      return;
+    }
+    await model.update({
+      where: {
+        id: documentId
+      },
+      data: {
+        status: 'indexing',
+        error: null
+      }
+    });
+    try {
+      const text = [doc.title, doc.content].filter(Boolean).join('\n\n');
+      const pieces = chunkText(text, {
+        strategy: this.r.chunkStrategy,
+        chunkSize: this.r.chunkSize,
+        chunkOverlap: this.r.chunkOverlap
+      });
+      const embeddings = await this.embedBatched(pieces);
+      const records = pieces.map((content, i) => ({
+        id: `${documentId}:${i}`,
+        documentId,
+        content,
+        embedding: embeddings[i],
+        title: doc.title,
+        source: doc.source,
+        tags: doc.tags,
+        metadata: doc.metadata
+      }));
+      await this.vectorStore.upsert(documentId, records);
+      await model.update({
+        where: {
+          id: documentId
+        },
+        data: {
+          status: 'indexed',
+          chunkCount: records.length,
+          error: null,
+          indexedAt: new Date()
+        }
+      });
+    } catch (err) {
+      await model.update({
+        where: {
+          id: documentId
+        },
+        data: {
+          status: 'error',
+          error: err instanceof Error ? err.message : String(err)
+        }
+      });
+      throw err;
+    }
+  }
+  async reindex(options = {}) {
+    const start = Date.now();
+    const docs = await this.listDocuments({
+      tags: options.tags
+    });
+    const targets = options.force ? docs : docs.filter(d => d.status !== 'indexed');
+    let chunks = 0;
+    let errors = 0;
+    await mapWithConcurrency(targets, this.r.indexing.concurrency, async d => {
+      try {
+        var _refreshed$chunkCount;
+        await this.index(d.id);
+        const refreshed = await this.getDocument(d.id);
+        chunks += (_refreshed$chunkCount = refreshed === null || refreshed === void 0 ? void 0 : refreshed.chunkCount) !== null && _refreshed$chunkCount !== void 0 ? _refreshed$chunkCount : 0;
+      } catch {
+        errors++;
+      }
+    });
+    return {
+      documents: targets.length,
+      chunks,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  async indexPending() {
+    const start = Date.now();
+    const pending = (await this.listDocuments()).filter(d => d.status === 'pending' || d.status === 'error');
+    let chunks = 0;
+    let errors = 0;
+    await mapWithConcurrency(pending, this.r.indexing.concurrency, async d => {
+      try {
+        var _refreshed$chunkCount2;
+        await this.index(d.id);
+        const refreshed = await this.getDocument(d.id);
+        chunks += (_refreshed$chunkCount2 = refreshed === null || refreshed === void 0 ? void 0 : refreshed.chunkCount) !== null && _refreshed$chunkCount2 !== void 0 ? _refreshed$chunkCount2 : 0;
+      } catch {
+        errors++;
+      }
+    });
+    return {
+      documents: pending.length,
+      chunks,
+      errors,
+      durationMs: Date.now() - start
+    };
+  }
+  async embedBatched(texts) {
+    if (texts.length === 0) return [];
+    const out = [];
+    const size = this.r.embeddingBatchSize;
+    for (let i = 0; i < texts.length; i += size) {
+      const batch = texts.slice(i, i + size);
+      out.push(...(await this.embedder.embed(batch, this.r.embeddingModel)));
+    }
+    return out;
+  }
+
+  // ── Retrieval ──
+
+  async retrieve(query, options = {}) {
+    var _options$topK, _options$minScore;
+    const topK = (_options$topK = options.topK) !== null && _options$topK !== void 0 ? _options$topK : this.r.topK;
+    const minScore = (_options$minScore = options.minScore) !== null && _options$minScore !== void 0 ? _options$minScore : this.r.minScore;
+    const [embedding] = await this.embedder.embed([query], this.r.embeddingModel);
+    if (!embedding) return [];
+    const candidates = await this.vectorStore.query({
+      embedding,
+      topK: Math.max(topK, topK * this.r.candidateMultiplier),
+      tags: options.tags,
+      minScore
+    });
+    let chunks = candidates.map(c => ({
+      id: c.id,
+      documentId: c.documentId,
+      title: c.title,
+      source: c.source,
+      content: c.content,
+      score: c.score,
+      tags: c.tags,
+      metadata: c.metadata
+    }));
+    if (this.rerank) chunks = await this.rerank(query, chunks);
+    return chunks.slice(0, topK);
+  }
+
+  // ── Chat ──
+
+  async ask(question, options = {}) {
+    return this.chat([{
+      role: 'user',
+      content: question
+    }], options);
+  }
+  async chat(messages, options = {}) {
+    const release = await this.chatGate.acquire();
+    try {
+      const prepared = await this.prepare(messages, options);
+      if (prepared.refusal) {
+        return {
+          text: prepared.refusal,
+          sources: [],
+          grounded: true,
+          refused: true,
+          model: this.generation.defaultModel
+        };
+      }
+      const result = await this.generation.generate(prepared.messages, prepared.genOptions);
+      return this.finalize(result.text, result.model, result.usage, prepared.context, options);
+    } finally {
+      release();
+    }
+  }
+  async *stream(messages, options = {}) {
+    const release = await this.chatGate.acquire();
+    try {
+      const prepared = await this.prepare(messages, options);
+      if (prepared.refusal) {
+        const answer = {
+          text: prepared.refusal,
+          sources: [],
+          grounded: true,
+          refused: true,
+          model: this.generation.defaultModel
+        };
+        yield {
+          type: 'token',
+          token: prepared.refusal
+        };
+        yield {
+          type: 'done',
+          answer
+        };
+        return;
+      }
+      yield {
+        type: 'sources',
+        sources: prepared.citations
+      };
+      let text = '';
+      let model = this.generation.defaultModel;
+      let usage;
+      if (this.generation.stream) {
+        for await (const part of this.generation.stream(prepared.messages, prepared.genOptions)) {
+          if (part.delta) {
+            text += part.delta;
+            yield {
+              type: 'token',
+              token: part.delta
+            };
+          }
+          if (part.done) {
+            var _part$model;
+            model = (_part$model = part.model) !== null && _part$model !== void 0 ? _part$model : model;
+            usage = part.usage;
+          }
+        }
+      } else {
+        const result = await this.generation.generate(prepared.messages, prepared.genOptions);
+        text = result.text;
+        model = result.model;
+        usage = result.usage;
+        yield {
+          type: 'token',
+          token: text
+        };
+      }
+      const answer = await this.finalize(text, model, usage, prepared.context, options);
+      // If the grounding check rewrote the answer to a refusal, surface that token too.
+      if (answer.refused && answer.text !== text) yield {
+        type: 'token',
+        token: answer.text
+      };
+      yield {
+        type: 'done',
+        answer
+      };
+    } catch (err) {
+      yield {
+        type: 'error',
+        error: err instanceof Error ? err.message : String(err)
+      };
+    } finally {
+      release();
+    }
+  }
+
+  /** Shared retrieve → guard → prompt pipeline for chat/stream. */
+  async prepare(messages, options) {
+    var _lastUser$content, _options$guard, _options$minScore2, _options$context, _options$model, _options$temperature, _options$maxTokens;
+    const turns = messages.filter(m => m.role !== 'system');
+    const lastUser = [...turns].reverse().find(m => m.role === 'user');
+    const question = (_lastUser$content = lastUser === null || lastUser === void 0 ? void 0 : lastUser.content) !== null && _lastUser$content !== void 0 ? _lastUser$content : '';
+    if (question.length > this.r.maxQueryChars) {
+      throw new Error(`[@nixxie-cms/ai-rag] Query exceeds the ${this.r.maxQueryChars}-character limit.`);
+    }
+    const guardOn = (_options$guard = options.guard) !== null && _options$guard !== void 0 ? _options$guard : this.r.guard.enabled;
+    const minScore = (_options$minScore2 = options.minScore) !== null && _options$minScore2 !== void 0 ? _options$minScore2 : this.r.minScore;
+    const context = (_options$context = options.context) !== null && _options$context !== void 0 ? _options$context : question ? await this.retrieve(question, options) : [];
+    if (guardOn && shouldRefuseForNoContext(context, this.r.guard, minScore)) {
+      return {
+        refusal: this.r.guard.refusal,
+        context: [],
+        citations: [],
+        messages: [],
+        genOptions: {}
+      };
+    }
+    const history = turns.slice(0, -1).slice(-this.r.historyLimit).map(m => ({
+      role: m.role,
+      content: m.content
+    }));
+    const systemBase = options.systemSuffix ? `${this.r.generation.systemPrompt}\n\n${options.systemSuffix}` : this.r.generation.systemPrompt;
+    const built = this.r.generation.buildPrompt ? this.r.generation.buildPrompt({
+      question,
+      history,
+      context,
+      systemPrompt: systemBase,
+      requireCitations: guardOn && this.r.guard.requireCitations
+    }) : buildRagPrompt({
+      question,
+      history,
+      context,
+      systemPrompt: systemBase,
+      requireCitations: guardOn && this.r.guard.requireCitations
+    }, {
+      maxContextChars: this.r.maxContextChars
+    });
+    const genOptions = {
+      system: built.system,
+      model: (_options$model = options.model) !== null && _options$model !== void 0 ? _options$model : this.r.generation.model,
+      temperature: (_options$temperature = options.temperature) !== null && _options$temperature !== void 0 ? _options$temperature : this.r.generation.temperature,
+      maxTokens: (_options$maxTokens = options.maxTokens) !== null && _options$maxTokens !== void 0 ? _options$maxTokens : this.r.generation.maxTokens,
+      topP: this.r.generation.topP
+    };
+    return {
+      context,
+      citations: toCitations(context),
+      messages: built.messages,
+      genOptions
+    };
+  }
+
+  /** Apply the grounding check and assemble the final answer with citations. */
+  async finalize(text, model, usage, context, options) {
+    var _options$guard2;
+    const guardOn = (_options$guard2 = options.guard) !== null && _options$guard2 !== void 0 ? _options$guard2 : this.r.guard.enabled;
+    let grounded = true;
+    if (guardOn && this.r.guard.groundingCheck) {
+      var _this$r$guard$groundi;
+      const check = await checkGrounding(this.generation, text, context, (_this$r$guard$groundi = this.r.guard.groundingModel) !== null && _this$r$guard$groundi !== void 0 ? _this$r$guard$groundi : this.r.generation.model);
+      grounded = check.grounded;
+      if (!grounded && this.r.guard.refuseWhenUngrounded) {
+        return {
+          text: this.r.guard.refusal,
+          sources: [],
+          grounded: false,
+          refused: true,
+          model,
+          usage
+        };
+      }
+    }
+    return {
+      text,
+      sources: toCitations(context),
+      grounded,
+      refused: false,
+      model,
+      usage
+    };
+  }
+  async close() {
+    // No long-lived resources to release; indexing runs are awaited by their callers.
+  }
+}
+function toCitations(chunks) {
+  return chunks.map(c => ({
+    documentId: c.documentId,
+    chunkId: c.id,
+    title: c.title,
+    source: c.source,
+    score: c.score,
+    snippet: snippet(c.content)
+  }));
+}
+function rowToDocument(row) {
+  var _row$title, _row$content, _row$source, _row$tags, _ref, _row$status, _row$chunkCount, _row$error, _row$createdAt, _ref2, _row$updatedAt, _row$indexedAt;
+  return {
+    id: String(row.id),
+    title: (_row$title = row.title) !== null && _row$title !== void 0 ? _row$title : undefined,
+    content: (_row$content = row.content) !== null && _row$content !== void 0 ? _row$content : '',
+    source: (_row$source = row.source) !== null && _row$source !== void 0 ? _row$source : undefined,
+    tags: Array.isArray(row.tags) ? row.tags : (_row$tags = row.tags) !== null && _row$tags !== void 0 ? _row$tags : undefined,
+    metadata: (_ref = row.metadata) !== null && _ref !== void 0 ? _ref : undefined,
+    status: (_row$status = row.status) !== null && _row$status !== void 0 ? _row$status : 'pending',
+    chunkCount: (_row$chunkCount = row.chunkCount) !== null && _row$chunkCount !== void 0 ? _row$chunkCount : 0,
+    error: (_row$error = row.error) !== null && _row$error !== void 0 ? _row$error : undefined,
+    createdAt: (_row$createdAt = row.createdAt) !== null && _row$createdAt !== void 0 ? _row$createdAt : new Date(),
+    updatedAt: (_ref2 = (_row$updatedAt = row.updatedAt) !== null && _row$updatedAt !== void 0 ? _row$updatedAt : row.createdAt) !== null && _ref2 !== void 0 ? _ref2 : new Date(),
+    indexedAt: (_row$indexedAt = row.indexedAt) !== null && _row$indexedAt !== void 0 ? _row$indexedAt : undefined
+  };
+}
+
+/** Run `fn` over items with at most `limit` in flight at once. */
+async function mapWithConcurrency(items, limit, fn) {
+  const queue = [...items];
+  const workers = Array.from({
+    length: Math.max(1, Math.min(limit, items.length))
+  }, async () => {
+    while (queue.length) {
+      const item = queue.shift();
+      await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
+
+/**
+ * The knowledge-base source list the assistant is trained on. Users add rows here; each
+ * row's `content` is chunked, embedded and made retrievable. `ragPlugin()` adds this
+ * collection automatically, but you can register it yourself for full control over access.
+ *
+ * @example
+ * config({
+ *   collections: { KnowledgeBase: knowledgeBaseCollection(), ...collections },
+ * })
+ */
+function knowledgeBaseCollection() {
+  return {
+    fields: {
+      title: text({
+        validation: {
+          isRequired: true
+        },
+        isIndexed: true
+      }),
+      content: text({
+        ui: {
+          displayMode: 'textarea'
+        },
+        validation: {
+          isRequired: true
+        }
+      }),
+      source: text(),
+      tags: json({
+        defaultValue: []
+      }),
+      metadata: json(),
+      status: select({
+        type: 'string',
+        options: [{
+          label: 'Pending',
+          value: 'pending'
+        }, {
+          label: 'Indexing',
+          value: 'indexing'
+        }, {
+          label: 'Indexed',
+          value: 'indexed'
+        }, {
+          label: 'Error',
+          value: 'error'
+        }, {
+          label: 'Disabled',
+          value: 'disabled'
+        }],
+        defaultValue: 'pending',
+        isIndexed: true,
+        ui: {
+          displayMode: 'segmented-control'
+        }
+      }),
+      chunkCount: integer({
+        defaultValue: 0
+      }),
+      error: text(),
+      indexedAt: timestamp(),
+      createdAt: timestamp({
+        defaultValue: {
+          kind: 'now'
+        },
+        db: {
+          isNullable: false
+        }
+      }),
+      updatedAt: timestamp({
+        db: {
+          updatedAt: true
+        }
+      })
+    },
+    ui: {
+      labelField: 'title',
+      description: 'Knowledge base the AI assistant is trained on.',
+      listView: {
+        initialColumns: ['title', 'status', 'chunkCount', 'tags', 'updatedAt'],
+        initialSort: {
+          field: 'updatedAt',
+          direction: 'DESC'
+        }
+      }
+    }
+  };
+}
+
+/**
+ * The chunk/embedding list backing retrieval. Managed entirely by ai-rag — rows are written
+ * during indexing and deleted with their document. Hidden from create/delete in the Admin UI.
+ * `ragPlugin()` adds it automatically.
+ */
+function knowledgeChunkCollection() {
+  return {
+    fields: {
+      documentId: text({
+        validation: {
+          isRequired: true
+        },
+        isIndexed: true
+      }),
+      content: text({
+        ui: {
+          displayMode: 'textarea'
+        }
+      }),
+      embedding: json(),
+      title: text(),
+      source: text(),
+      tags: json({
+        defaultValue: []
+      }),
+      metadata: json(),
+      createdAt: timestamp({
+        defaultValue: {
+          kind: 'now'
+        },
+        db: {
+          isNullable: false
+        }
+      })
+    },
+    graphql: {
+      omit: {
+        create: true,
+        update: true,
+        delete: true
+      }
+    },
+    ui: {
+      isHidden: true,
+      labelField: 'title',
+      hideCreate: true,
+      hideDelete: true,
+      itemView: {
+        defaultFieldMode: 'read'
+      }
+    }
+  };
+}
+
+function getService(context, options) {
+  var _options$service;
+  const svc = (_options$service = options.service) !== null && _options$service !== void 0 ? _options$service : context.services.aiRag;
+  if (!svc) {
+    throw new Error('[@nixxie-cms/ai-rag] No aiRag service configured. Pass `service` or set `config({ aiRag })`.');
+  }
+  return svc;
+}
+
+/** Read a JSON body whether or not a body parser ran upstream. */
+async function readJson(req) {
+  if (req.body && typeof req.body === 'object') return req.body;
+  return new Promise(resolve => {
+    let raw = '';
+    req.on('data', c => raw += c);
+    req.on('end', () => {
+      try {
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch {
+        resolve({});
+      }
+    });
+    req.on('error', () => resolve({}));
+  });
+}
+function writeSse(res, event) {
+  const type = event.type;
+  res.write(`event: ${type}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+
+/**
+ * Mount the assistant's HTTP API on an Express app:
+ *
+ * - `POST <path>/chat` — body `{ messages?, question?, topK?, tags?, stream? }`. When
+ *   `stream` is true (or `Accept: text/event-stream`), responds with SSE: `sources`,
+ *   then `token` events, then a final `done` event carrying the full answer.
+ * - `GET <path>/documents` — list knowledge-base documents.
+ * - `POST <path>/documents` — add a document `{ content, title?, source?, tags? }`.
+ * - `DELETE <path>/documents/:id` — remove a document.
+ * - `POST <path>/reindex` — `{ force? }` → index stats.
+ *
+ * Call from `server.extendExpressApp`, or use `ragPlugin()` to wire it automatically.
+ */
+function installAiRagRoutes(app, context, options = {}) {
+  var _options$path, _options$protectReads;
+  const path = ((_options$path = options.path) !== null && _options$path !== void 0 ? _options$path : '/api/ai-rag').replace(/\/$/, '');
+  const protectReads = (_options$protectReads = options.protectReads) !== null && _options$protectReads !== void 0 ? _options$protectReads : true;
+  const authorize = async (req, res) => {
+    var _options$isAuthorized;
+    const requestContext = await context.withRequest(req, res);
+    const check = (_options$isAuthorized = options.isAuthorized) !== null && _options$isAuthorized !== void 0 ? _options$isAuthorized : c => !!c.session;
+    if (!(await check(requestContext))) {
+      res.statusCode = 401;
+      res.end('Unauthorized');
+      return null;
+    }
+    return requestContext;
+  };
+  const wrap = (handler, gated) => (req, res) => {
+    void (async () => {
+      const ctx = gated ? await authorize(req, res) : await context.withRequest(req, res);
+      if (!ctx) return;
+      await handler(req, res, ctx);
+    })().catch(err => {
+      console.error('[@nixxie-cms/ai-rag] Route error:', err);
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader('Content-Type', 'application/json');
+        res.end(JSON.stringify({
+          error: err instanceof Error ? err.message : 'Internal error'
+        }));
+      } else {
+        res.end();
+      }
+    });
+  };
+
+  // ── Chat (streaming or one-shot) ──
+  app.post(`${path}/chat`, wrap(async (req, res, ctx) => {
+    var _req$headers$accept, _req$headers, _res$flushHeaders, _req$on;
+    const svc = getService(ctx, options);
+    const body = await readJson(req);
+    const messages = Array.isArray(body.messages) && body.messages.length ? body.messages : body.question ? [{
+      role: 'user',
+      content: String(body.question)
+    }] : [];
+    if (!messages.length) {
+      res.statusCode = 400;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({
+        error: 'Provide `messages` or `question`.'
+      }));
+      return;
+    }
+    const askOptions = {
+      topK: body.topK,
+      tags: body.tags,
+      temperature: body.temperature,
+      model: body.model
+    };
+    const wantsStream = body.stream === true || String((_req$headers$accept = (_req$headers = req.headers) === null || _req$headers === void 0 ? void 0 : _req$headers.accept) !== null && _req$headers$accept !== void 0 ? _req$headers$accept : '').includes('text/event-stream');
+    if (!wantsStream) {
+      const answer = await svc.chat(messages, askOptions);
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify(answer));
+      return;
+    }
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    (_res$flushHeaders = res.flushHeaders) === null || _res$flushHeaders === void 0 || _res$flushHeaders.call(res);
+    let aborted = false;
+    (_req$on = req.on) === null || _req$on === void 0 || _req$on.call(req, 'close', () => aborted = true);
+    for await (const event of svc.stream(messages, askOptions)) {
+      if (aborted) break;
+      writeSse(res, event);
+    }
+    res.end();
+  }, protectReads));
+
+  // ── Documents CRUD ──
+  app.get(`${path}/documents`, wrap(async (req, res, ctx) => {
+    var _req$query, _req$query2, _req$query3;
+    const svc = getService(ctx, options);
+    const take = (_req$query = req.query) !== null && _req$query !== void 0 && _req$query.take ? Number(req.query.take) : undefined;
+    const skip = (_req$query2 = req.query) !== null && _req$query2 !== void 0 && _req$query2.skip ? Number(req.query.skip) : undefined;
+    const docs = await svc.listDocuments({
+      take,
+      skip,
+      search: (_req$query3 = req.query) === null || _req$query3 === void 0 ? void 0 : _req$query3.search
+    });
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({
+      documents: docs
+    }));
+  }, protectReads));
+  app.post(`${path}/documents`, wrap(async (req, res, ctx) => {
+    const svc = getService(ctx, options);
+    const body = await readJson(req);
+    if (!body.content) {
+      res.statusCode = 400;
+      res.setHeader('Content-Type', 'application/json');
+      res.end(JSON.stringify({
+        error: '`content` is required.'
+      }));
+      return;
+    }
+    const doc = await svc.addDocument({
+      content: String(body.content),
+      title: body.title,
+      source: body.source,
+      tags: body.tags,
+      metadata: body.metadata
+    });
+    res.statusCode = 201;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify(doc));
+  }, true));
+  app.delete(`${path}/documents/:id`, wrap(async (req, res, ctx) => {
+    const svc = getService(ctx, options);
+    await svc.removeDocument(req.params.id);
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({
+      ok: true
+    }));
+  }, true));
+  app.post(`${path}/reindex`, wrap(async (req, res, ctx) => {
+    const svc = getService(ctx, options);
+    const body = await readJson(req);
+    const stats = await svc.reindex({
+      force: !!body.force
+    });
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify(stats));
+  }, true));
+}
+
+/** How the GraphQL resolvers obtain the service (defaults to `context.services.aiRag`). */
+
+function serviceFrom(context, options) {
+  var _options$getService;
+  const svc = ((_options$getService = options.getService) !== null && _options$getService !== void 0 ? _options$getService : c => c.services.aiRag)(context);
+  if (!svc) {
+    throw new Error('[@nixxie-cms/ai-rag] No aiRag service is configured. Pass it to `config({ aiRag })` or `ragPlugin({ service })`.');
+  }
+  return svc;
+}
+async function assertAuthorized(context, options) {
+  var _options$isAuthorized;
+  const check = (_options$isAuthorized = options.isAuthorized) !== null && _options$isAuthorized !== void 0 ? _options$isAuthorized : c => !!c.session;
+  if (!(await check(context))) {
+    throw new Error('[@nixxie-cms/ai-rag] Not authorized.');
+  }
+}
+
+/**
+ * Build the `extendGraphqlSchema` function that adds the assistant's queries and mutations:
+ *
+ * - `ragAsk(question, topK?, tags?)` → grounded answer with citations
+ * - `ragRetrieve(query, topK?, tags?)` → raw retrieved chunks
+ * - `ragAddDocument(...)` / `ragRemoveDocument(id)` / `ragReindex(force?)`
+ *
+ * `ragPlugin()` wires this automatically; use it directly only if you compose the schema yourself.
+ */
+function ragGraphqlExtension(options = {}) {
+  return g.extend(() => {
+    const Citation = g.object()({
+      name: 'RagCitation',
+      fields: {
+        documentId: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.documentId
+        }),
+        chunkId: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.chunkId
+        }),
+        title: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$title;
+            return (_s$title = s.title) !== null && _s$title !== void 0 ? _s$title : null;
+          }
+        }),
+        source: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$source;
+            return (_s$source = s.source) !== null && _s$source !== void 0 ? _s$source : null;
+          }
+        }),
+        score: g.field({
+          type: g.nonNull(g.Float),
+          resolve: s => s.score
+        }),
+        snippet: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.snippet
+        })
+      }
+    });
+    const Chunk = g.object()({
+      name: 'RagChunk',
+      fields: {
+        id: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.id
+        }),
+        documentId: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.documentId
+        }),
+        title: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$title2;
+            return (_s$title2 = s.title) !== null && _s$title2 !== void 0 ? _s$title2 : null;
+          }
+        }),
+        source: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$source2;
+            return (_s$source2 = s.source) !== null && _s$source2 !== void 0 ? _s$source2 : null;
+          }
+        }),
+        content: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.content
+        }),
+        score: g.field({
+          type: g.nonNull(g.Float),
+          resolve: s => s.score
+        })
+      }
+    });
+    const Answer = g.object()({
+      name: 'RagAnswer',
+      fields: {
+        text: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.text
+        }),
+        grounded: g.field({
+          type: g.nonNull(g.Boolean),
+          resolve: s => s.grounded
+        }),
+        refused: g.field({
+          type: g.nonNull(g.Boolean),
+          resolve: s => s.refused
+        }),
+        model: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.model
+        }),
+        sources: g.field({
+          type: g.nonNull(g.list(g.nonNull(Citation))),
+          resolve: s => s.sources
+        })
+      }
+    });
+    const Document = g.object()({
+      name: 'RagDocument',
+      fields: {
+        id: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.id
+        }),
+        title: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$title3;
+            return (_s$title3 = s.title) !== null && _s$title3 !== void 0 ? _s$title3 : null;
+          }
+        }),
+        content: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.content
+        }),
+        source: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$source3;
+            return (_s$source3 = s.source) !== null && _s$source3 !== void 0 ? _s$source3 : null;
+          }
+        }),
+        tags: g.field({
+          type: g.list(g.nonNull(g.String)),
+          resolve: s => {
+            var _s$tags;
+            return (_s$tags = s.tags) !== null && _s$tags !== void 0 ? _s$tags : null;
+          }
+        }),
+        status: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.status
+        }),
+        chunkCount: g.field({
+          type: g.nonNull(g.Int),
+          resolve: s => s.chunkCount
+        }),
+        error: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$error;
+            return (_s$error = s.error) !== null && _s$error !== void 0 ? _s$error : null;
+          }
+        }),
+        indexedAt: g.field({
+          type: g.String,
+          resolve: s => {
+            var _s$indexedAt$toISOStr, _s$indexedAt;
+            return (_s$indexedAt$toISOStr = (_s$indexedAt = s.indexedAt) === null || _s$indexedAt === void 0 ? void 0 : _s$indexedAt.toISOString()) !== null && _s$indexedAt$toISOStr !== void 0 ? _s$indexedAt$toISOStr : null;
+          }
+        }),
+        createdAt: g.field({
+          type: g.nonNull(g.String),
+          resolve: s => s.createdAt.toISOString()
+        })
+      }
+    });
+    const IndexStats = g.object()({
+      name: 'RagIndexStats',
+      fields: {
+        documents: g.field({
+          type: g.nonNull(g.Int),
+          resolve: s => s.documents
+        }),
+        chunks: g.field({
+          type: g.nonNull(g.Int),
+          resolve: s => s.chunks
+        }),
+        errors: g.field({
+          type: g.nonNull(g.Int),
+          resolve: s => s.errors
+        }),
+        durationMs: g.field({
+          type: g.nonNull(g.Int),
+          resolve: s => s.durationMs
+        })
+      }
+    });
+    return {
+      query: {
+        ragAsk: g.field({
+          type: g.nonNull(Answer),
+          args: {
+            question: g.arg({
+              type: g.nonNull(g.String)
+            }),
+            topK: g.arg({
+              type: g.Int
+            }),
+            tags: g.arg({
+              type: g.list(g.nonNull(g.String))
+            })
+          },
+          resolve: async (_s, args, context) => {
+            var _args$topK, _args$tags;
+            return serviceFrom(context, options).ask(args.question, {
+              topK: (_args$topK = args.topK) !== null && _args$topK !== void 0 ? _args$topK : undefined,
+              tags: (_args$tags = args.tags) !== null && _args$tags !== void 0 ? _args$tags : undefined
+            });
+          }
+        }),
+        ragRetrieve: g.field({
+          type: g.nonNull(g.list(g.nonNull(Chunk))),
+          args: {
+            query: g.arg({
+              type: g.nonNull(g.String)
+            }),
+            topK: g.arg({
+              type: g.Int
+            }),
+            tags: g.arg({
+              type: g.list(g.nonNull(g.String))
+            })
+          },
+          resolve: async (_s, args, context) => {
+            var _args$topK2, _args$tags2;
+            return serviceFrom(context, options).retrieve(args.query, {
+              topK: (_args$topK2 = args.topK) !== null && _args$topK2 !== void 0 ? _args$topK2 : undefined,
+              tags: (_args$tags2 = args.tags) !== null && _args$tags2 !== void 0 ? _args$tags2 : undefined
+            });
+          }
+        })
+      },
+      mutation: {
+        ragAddDocument: g.field({
+          type: g.nonNull(Document),
+          args: {
+            content: g.arg({
+              type: g.nonNull(g.String)
+            }),
+            title: g.arg({
+              type: g.String
+            }),
+            source: g.arg({
+              type: g.String
+            }),
+            tags: g.arg({
+              type: g.list(g.nonNull(g.String))
+            })
+          },
+          resolve: async (_s, args, context) => {
+            var _args$title, _args$source, _args$tags3;
+            await assertAuthorized(context, options);
+            return serviceFrom(context, options).addDocument({
+              content: args.content,
+              title: (_args$title = args.title) !== null && _args$title !== void 0 ? _args$title : undefined,
+              source: (_args$source = args.source) !== null && _args$source !== void 0 ? _args$source : undefined,
+              tags: (_args$tags3 = args.tags) !== null && _args$tags3 !== void 0 ? _args$tags3 : undefined
+            });
+          }
+        }),
+        ragRemoveDocument: g.field({
+          type: g.nonNull(g.Boolean),
+          args: {
+            id: g.arg({
+              type: g.nonNull(g.String)
+            })
+          },
+          resolve: async (_s, args, context) => {
+            await assertAuthorized(context, options);
+            await serviceFrom(context, options).removeDocument(args.id);
+            return true;
+          }
+        }),
+        ragReindex: g.field({
+          type: g.nonNull(IndexStats),
+          args: {
+            force: g.arg({
+              type: g.Boolean
+            })
+          },
+          resolve: async (_s, args, context) => {
+            var _args$force;
+            await assertAuthorized(context, options);
+            return serviceFrom(context, options).reindex({
+              force: (_args$force = args.force) !== null && _args$force !== void 0 ? _args$force : false
+            });
+          }
+        })
+      }
+    };
+  });
+}
+
+/** Re-index on CMS create/update, purge chunks on delete. Skips the service's own status writes. */
+function autoIndexHooks(service) {
+  return {
+    afterOperation: async args => {
+      try {
+        var _args$originalItem2, _args$originalItem3;
+        if (args.operation === 'delete') {
+          var _args$originalItem;
+          const id = (_args$originalItem = args.originalItem) === null || _args$originalItem === void 0 ? void 0 : _args$originalItem.id;
+          if (id != null) await service.purgeChunks(String(id));
+          return;
+        }
+        const item = args.item;
+        if (!(item !== null && item !== void 0 && item.id)) return;
+        // Only (re)index when indexable content actually changed — the service's own
+        // status/chunkCount writes go through raw Prisma and never reach this hook, but
+        // this also avoids needless work on unrelated field edits.
+        const changed = args.operation === 'create' || item.content !== ((_args$originalItem2 = args.originalItem) === null || _args$originalItem2 === void 0 ? void 0 : _args$originalItem2.content) || item.title !== ((_args$originalItem3 = args.originalItem) === null || _args$originalItem3 === void 0 ? void 0 : _args$originalItem3.title);
+        if (changed) await service.index(String(item.id));
+      } catch (err) {
+        console.error('[@nixxie-cms/ai-rag] Auto-index hook failed:', err);
+      }
+    }
+  };
+}
+function composeExtendExpress(previous, service, routes) {
+  const routeOptions = typeof routes === 'object' ? routes : {};
+  return async (app, context) => {
+    await (previous === null || previous === void 0 ? void 0 : previous(app, context));
+    if (routes !== false) installAiRagRoutes(app, context, {
+      ...routeOptions,
+      service
+    });
+  };
+}
+function composeExtendGraphql(previous, graphqlOption) {
+  if (graphqlOption === false) return previous;
+  const ext = ragGraphqlExtension(typeof graphqlOption === 'object' ? graphqlOption : {});
+  return schema => ext(previous ? previous(schema) : schema);
+}
+
+/**
+ * One-call wiring for the RAG assistant. Registers the service, adds the knowledge-base
+ * collections (with auto-indexing hooks), mounts the HTTP + GraphQL surfaces and schedules
+ * re-indexing.
+ *
+ * @example
+ * import { createAiRag, ragPlugin } from '@nixxie-cms/ai-rag'
+ * const aiRag = createAiRag({
+ *   generation: { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY! },
+ *   embedding: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY! },
+ *   indexing: { schedule: '0 3 * * *' },
+ * })
+ * export default config({
+ *   db: { ... },
+ *   plugins: [ragPlugin({ service: aiRag })],
+ * })
+ */
+function ragPlugin(options) {
+  var _options$autoIndex, _options$jobName;
+  const {
+    service
+  } = options;
+  const {
+    documents,
+    chunks
+  } = service.collections;
+  const autoIndex = (_options$autoIndex = options.autoIndex) !== null && _options$autoIndex !== void 0 ? _options$autoIndex : true;
+  const jobName = (_options$jobName = options.jobName) !== null && _options$jobName !== void 0 ? _options$jobName : 'ai-rag-reindex';
+  const collections = options.collections === false ? undefined : {
+    [documents]: autoIndex ? {
+      ...knowledgeBaseCollection(),
+      hooks: autoIndexHooks(service)
+    } : knowledgeBaseCollection(),
+    [chunks]: knowledgeChunkCollection()
+  };
+  return {
+    name: 'nixxie-ai-rag',
+    collections,
+    extendConfig: config => {
+      var _config$aiRag, _config$graphql, _config$server;
+      return {
+        ...config,
+        // Register the service so core initialises it and it's reachable via context.services.aiRag.
+        aiRag: (_config$aiRag = config.aiRag) !== null && _config$aiRag !== void 0 ? _config$aiRag : service,
+        graphql: {
+          ...config.graphql,
+          extendGraphqlSchema: composeExtendGraphql((_config$graphql = config.graphql) === null || _config$graphql === void 0 ? void 0 : _config$graphql.extendGraphqlSchema, options.graphql)
+        },
+        server: {
+          ...config.server,
+          extendExpressApp: composeExtendExpress((_config$server = config.server) === null || _config$server === void 0 ? void 0 : _config$server.extendExpressApp, service, options.routes)
+        }
+      };
+    },
+    onConnect: async context => {
+      // The service itself is initialised by core's service-init loop (because we set
+      // config.aiRag above). Here we only schedule the periodic full reindex, if requested.
+      const schedule = service.indexingSchedule;
+      if (schedule && context.services.jobs) {
+        context.services.jobs.define({
+          name: jobName,
+          schedule,
+          handler: async () => {
+            await service.reindex();
+          }
+        });
+      } else if (schedule && !context.services.jobs) {
+        console.warn(`[@nixxie-cms/ai-rag] indexing.schedule is set but no jobs service is configured — ` + `add \`jobs: createJobs()\` from @nixxie-cms/jobs to enable scheduled re-indexing.`);
+      }
+    }
+  };
+}
+
+/** Source of the self-contained Admin UI page (plain React + fetch, no extra deps). */
+function pageSource(apiPath, title) {
+  return `// Generated by @nixxie-cms/ai-rag — a chat + knowledge-base console for the Admin UI.
+import React, { useState } from 'react'
+
+const API = ${JSON.stringify(apiPath)}
+
+export default function AiRagPage() {
+  const [messages, setMessages] = useState([])
+  const [input, setInput] = useState('')
+  const [busy, setBusy] = useState(false)
+  const [docTitle, setDocTitle] = useState('')
+  const [docContent, setDocContent] = useState('')
+
+  async function send() {
+    const question = input.trim()
+    if (!question || busy) return
+    setInput('')
+    const next = [...messages, { role: 'user', content: question }]
+    setMessages(next)
+    setBusy(true)
+    try {
+      const res = await fetch(API + '/chat', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ messages: next, stream: false }),
+      })
+      const answer = await res.json()
+      const sources = (answer.sources || [])
+        .map(function (s, i) { return '[' + (i + 1) + '] ' + (s.title || s.source || s.documentId) })
+        .join('  ')
+      setMessages(function (m) {
+        return m.concat([{ role: 'assistant', content: answer.text + (sources ? '\\n\\nSources: ' + sources : '') }])
+      })
+    } catch (err) {
+      setMessages(function (m) { return m.concat([{ role: 'assistant', content: 'Error: ' + String(err) }]) })
+    } finally {
+      setBusy(false)
+    }
+  }
+
+  async function addDocument() {
+    if (!docContent.trim()) return
+    await fetch(API + '/documents', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title: docTitle, content: docContent }),
+    })
+    setDocTitle('')
+    setDocContent('')
+    alert('Document added and queued for indexing.')
+  }
+
+  return (
+    React.createElement('div', { style: { maxWidth: 820, margin: '0 auto', padding: 24 } },
+      React.createElement('h1', { style: { fontSize: 24, fontWeight: 700, marginBottom: 16 } }, ${JSON.stringify(title)}),
+      React.createElement('div', { style: { border: '1px solid #e2e8f0', borderRadius: 8, padding: 16, minHeight: 240, marginBottom: 12 } },
+        messages.length === 0
+          ? React.createElement('p', { style: { color: '#94a3b8' } }, 'Ask the assistant a question about your knowledge base…')
+          : messages.map(function (m, i) {
+              return React.createElement('div', { key: i, style: { margin: '8px 0' } },
+                React.createElement('strong', null, m.role === 'user' ? 'You: ' : 'Assistant: '),
+                React.createElement('span', { style: { whiteSpace: 'pre-wrap' } }, m.content))
+            })
+      ),
+      React.createElement('div', { style: { display: 'flex', gap: 8, marginBottom: 32 } },
+        React.createElement('input', {
+          value: input,
+          onChange: function (e) { setInput(e.target.value) },
+          onKeyDown: function (e) { if (e.key === 'Enter') send() },
+          placeholder: 'Type your question…',
+          style: { flex: 1, padding: 8, borderRadius: 6, border: '1px solid #cbd5e1' },
+        }),
+        React.createElement('button', { onClick: send, disabled: busy, style: { padding: '8px 16px' } }, busy ? '…' : 'Send')
+      ),
+      React.createElement('h2', { style: { fontSize: 18, fontWeight: 600, marginBottom: 8 } }, 'Add to knowledge base'),
+      React.createElement('input', {
+        value: docTitle,
+        onChange: function (e) { setDocTitle(e.target.value) },
+        placeholder: 'Title',
+        style: { width: '100%', padding: 8, borderRadius: 6, border: '1px solid #cbd5e1', marginBottom: 8 },
+      }),
+      React.createElement('textarea', {
+        value: docContent,
+        onChange: function (e) { setDocContent(e.target.value) },
+        placeholder: 'Content the assistant should learn from…',
+        rows: 6,
+        style: { width: '100%', padding: 8, borderRadius: 6, border: '1px solid #cbd5e1', marginBottom: 8 },
+      }),
+      React.createElement('button', { onClick: addDocument, style: { padding: '8px 16px' } }, 'Add document')
+    )
+  )
+}
+`;
+}
+
+/**
+ * Returns an `AdminFileToWrite` that adds a chat + knowledge-base console page to the
+ * Admin UI. Spread it into `ui.getAdditionalFiles`:
+ *
+ * @example
+ * import { ragAdminPage } from '@nixxie-cms/ai-rag'
+ * export default config({
+ *   ui: { getAdditionalFiles: [async () => [ragAdminPage()]] },
+ * })
+ *
+ * The page appears at `/<route>` (default `/ai-rag`) in the Admin UI.
+ */
+function ragAdminPage(options = {}) {
+  var _options$route, _options$apiPath, _options$title;
+  const route = (_options$route = options.route) !== null && _options$route !== void 0 ? _options$route : 'ai-rag';
+  const apiPath = ((_options$apiPath = options.apiPath) !== null && _options$apiPath !== void 0 ? _options$apiPath : '/api/ai-rag').replace(/\/$/, '');
+  const title = (_options$title = options.title) !== null && _options$title !== void 0 ? _options$title : 'AI Assistant';
+  return {
+    mode: 'write',
+    src: pageSource(apiPath, title),
+    outputPath: `pages/${route}.js`
+  };
+}
+
+/**
+ * Create a custom, RAG-trained assistant backed by a knowledge-base collection.
+ *
+ * Register it with `ragPlugin()` so the knowledge-base collections, HTTP + GraphQL surfaces
+ * and scheduled indexing are wired automatically:
+ *
+ * @example
+ * import { createAiRag, ragPlugin } from '@nixxie-cms/ai-rag'
+ * const aiRag = createAiRag({
+ *   generation: { provider: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY! },
+ *   embedding: { provider: 'openai', apiKey: process.env.OPENAI_API_KEY! },
+ *   retrieval: { topK: 6, minScore: 0.25 },
+ *   guard: { groundingCheck: true },
+ *   indexing: { schedule: '0 3 * * *' },
+ * })
+ * export default config({ db: { ... }, plugins: [ragPlugin({ service: aiRag })] })
+ *
+ * Then anywhere you have context:
+ *   await context.services.aiRag!.addDocument({ title, content })
+ *   const answer = await context.services.aiRag!.ask('How do refunds work?')
+ */
+function createAiRag(config = {}) {
+  return new AiRagService(config);
+}
+
+// Config + value types
+
+// Re-exported service types from core
+
+export { AiRagService, AnthropicRagProvider, DEFAULT_SYSTEM_PROMPT, GeminiRagProvider, InMemoryVectorStore, OllamaRagProvider, OpenAiRagProvider, ServiceRagProvider, SqlVectorStore, buildRagPrompt, chunkText, cosineSimilarity, createAiRag, installAiRagRoutes, knowledgeBaseCollection, knowledgeChunkCollection, normalize, ragAdminPage, ragGraphqlExtension, ragPlugin, renderContext, resolveEmbeddingProvider, resolveGenerationProvider };