@devilsdev/rag-guardrails 3.4.0 → 3.5.0

package/README.md

@@ -8,7 +8,7 @@ Part of [@devilsdev/rag-pipeline-utils](https://www.npmjs.com/package/@devilsdev
 npm install @devilsdev/rag-guardrails
 ```
 
-Exports: `PreRetrievalGuard`, `detectInjection`, `RetrievalGuard`, `PostGenerationGuard`, `GuardrailsPipeline`.
+Exports: `PreRetrievalGuard`, `detectInjection`, `patternInjectionDetector`, `patternPIIDetector`, `detectedText`, `evaluateDetectors`, `detectorVerdict`, `renderDetectorReport`, `RetrievalGuard`, `PostGenerationGuard`, `GuardrailsPipeline`.
 
 Documentation: https://devilsdev.github.io/rag-pipeline-utils/
 

package/dist/index.cjs

@@ -249,6 +249,156 @@ var require_injection_detector = __commonJS({
   }
 });
 
+// src/guardrails/detectors.js
+var require_detectors = __commonJS({
+  "src/guardrails/detectors.js"(exports2, module2) {
+    "use strict";
+    var { detectInjection } = require_injection_detector();
+    var KINDS = ["injection", "pii"];
+    var DEFAULT_PII_PATTERNS = {
+      email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+      phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
+      ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
+      creditCard: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g
+    };
+    function patternInjectionDetector({ patterns = [] } = {}) {
+      return {
+        name: "pattern-injection",
+        kind: "injection",
+        detect(text) {
+          const found = detectInjection(String(text ?? ""), { patterns });
+          return {
+            flagged: found.detected,
+            labels: [...new Set(found.matches.map((m) => m.id))],
+            matches: found.matches.map((m) => ({ label: m.id, text: m.match }))
+          };
+        }
+      };
+    }
+    function patternPIIDetector({ patterns } = {}) {
+      const all = { ...DEFAULT_PII_PATTERNS, ...patterns };
+      return {
+        name: "pattern-pii",
+        kind: "pii",
+        detect(text) {
+          const matches = [];
+          for (const [label, pattern] of Object.entries(all)) {
+            const re = new RegExp(
+              pattern.source,
+              pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`
+            );
+            for (const m of String(text ?? "").matchAll(re)) {
+              if (m[0]) {
+                matches.push({
+                  label,
+                  text: m[0],
+                  start: m.index,
+                  end: m.index + m[0].length
+                });
+              }
+            }
+          }
+          return {
+            flagged: matches.length > 0,
+            labels: [...new Set(matches.map((m) => m.label))],
+            matches
+          };
+        }
+      };
+    }
+    function resolveDetectors(guard, kind, options = {}) {
+      const { detectors = [], builtIn = true } = options;
+      if (!Array.isArray(detectors)) {
+        throw new TypeError(`${guard}: detectors must be an array`);
+      }
+      for (const d of detectors) {
+        if (!d || typeof d !== "object" || typeof d.detect !== "function" || typeof d.name !== "string" || !KINDS.includes(d.kind)) {
+          throw new TypeError(
+            `${guard}: a detector is { name, kind: 'injection' | 'pii', detect(text, context) }`
+          );
+        }
+        if (d.kind !== kind) {
+          throw new TypeError(
+            `${guard} runs ${kind} detectors; "${d.name}" is a ${d.kind} detector`
+          );
+        }
+      }
+      if (builtIn === false && detectors.length === 0) {
+        throw new TypeError(
+          `${guard}: builtIn: false needs at least one ${kind} detector, or the check is off`
+        );
+      }
+      const onDetectorError = options.onDetectorError ?? "block";
+      if (onDetectorError !== "block" && onDetectorError !== "skip") {
+        throw new TypeError(`${guard}: onDetectorError must be 'block' or 'skip'`);
+      }
+      return detectors;
+    }
+    function normalise(detector, raw) {
+      const r = raw && typeof raw === "object" ? raw : { flagged: Boolean(raw) };
+      const matches = Array.isArray(r.matches) ? r.matches.filter((m) => m && typeof m === "object").map((m) => ({ ...m, text: m.text == null ? "" : String(m.text) })) : [];
+      return {
+        detector: detector.name,
+        kind: detector.kind,
+        flagged: Boolean(r.flagged),
+        ...typeof r.score === "number" && { score: r.score },
+        ...Array.isArray(r.labels) && { labels: r.labels.map(String) },
+        matches
+      };
+    }
+    function failed(detector, error) {
+      return {
+        detector: detector.name,
+        kind: detector.kind,
+        flagged: false,
+        matches: [],
+        error: String(error && error.message || error)
+      };
+    }
+    function runDetectorsSync(detectors, text, context, { guard, asyncMethod }) {
+      return detectors.map((detector) => {
+        let raw;
+        try {
+          raw = detector.detect(text, context);
+        } catch (error) {
+          return failed(detector, error);
+        }
+        if (raw && typeof raw.then === "function") {
+          Promise.resolve(raw).catch(() => {
+          });
+          throw new TypeError(
+            `${guard}: detector "${detector.name}" is async; use ${asyncMethod}()`
+          );
+        }
+        return normalise(detector, raw);
+      });
+    }
+    function runDetectorsAsync(detectors, text, context) {
+      return Promise.all(
+        detectors.map(async (detector) => {
+          try {
+            return normalise(detector, await detector.detect(text, context));
+          } catch (error) {
+            return failed(detector, error);
+          }
+        })
+      );
+    }
+    function detectedText(result) {
+      return result && Array.isArray(result.matchedText) && result.matchedText || [];
+    }
+    module2.exports = {
+      DEFAULT_PII_PATTERNS,
+      patternInjectionDetector,
+      patternPIIDetector,
+      resolveDetectors,
+      runDetectorsSync,
+      runDetectorsAsync,
+      detectedText
+    };
+  }
+});
+
 // src/guardrails/pre-retrieval-guard.js
 var require_pre_retrieval_guard = __commonJS({
   "src/guardrails/pre-retrieval-guard.js"(exports2, module2) {
@@ -257,6 +407,11 @@ var require_pre_retrieval_guard = __commonJS({
     var { validateInput } = require_validator();
     var { tokenize } = require_scoring();
     var { detectInjection, DEFAULT_RULES } = require_injection_detector();
+    var {
+      resolveDetectors,
+      runDetectorsSync,
+      runDetectorsAsync
+    } = require_detectors();
     var DEFAULT_CONFIG = {
       maxQueryLength: 1e4,
       enableInjectionDetection: true,
@@ -277,9 +432,17 @@ var require_pre_retrieval_guard = __commonJS({
        * @param {string[]} [options.blockedTopics=[]] - Topics to reject
        * @param {string[]} [options.allowedTopics=[]] - If non-empty, only these topics are permitted
        * @param {RegExp[]} [options.injectionPatterns] - Additional injection patterns (merged with defaults)
+       * @param {Array<object>} [options.detectors=[]] - Injection detectors to run on the query as well (see ./detectors); async ones need checkAsync()
+       * @param {boolean} [options.builtIn=true] - false: use only `detectors`, not the built-in patterns
+       * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws makes the query unsafe ('block') or is ignored ('skip')
        */
       constructor(options = {}) {
         super();
+        this._detectors = resolveDetectors(
+          "PreRetrievalGuard",
+          "injection",
+          options
+        );
         this.config = { ...DEFAULT_CONFIG, ...options };
         this._customPatterns = options.injectionPatterns ? [...options.injectionPatterns] : [];
         if (options.injectionPatterns) {
@@ -306,17 +469,54 @@ var require_pre_retrieval_guard = __commonJS({
        * @fires PreRetrievalGuard#checked
        */
       check(query) {
+        const state = this._prepare(query);
+        if (state.result) return this._emit(state.result);
+        const detections = this._runDetectors(state) ? runDetectorsSync(this._detectors, state.sanitizedQuery, CONTEXT, {
+          guard: "PreRetrievalGuard",
+          asyncMethod: "checkAsync"
+        }) : [];
+        return this._finish(state, detections);
+      }
+      /**
+       * check() for async detectors, such as a classifier model or a service.
+       * Detectors run concurrently.
+       *
+       * @param {string} query
+       * @param {object} [options]
+       * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+       * @returns {Promise<ReturnType<PreRetrievalGuard['check']>>}
+       */
+      async checkAsync(query, { signal } = {}) {
+        const state = this._prepare(query);
+        if (state.result) return this._emit(state.result);
+        const detections = this._runDetectors(state) ? await runDetectorsAsync(this._detectors, state.sanitizedQuery, {
+          ...CONTEXT,
+          ...signal && { signal }
+        }) : [];
+        return this._finish(state, detections);
+      }
+      /** @private */
+      _runDetectors() {
+        return this.config.enableInjectionDetection && this._detectors.length > 0;
+      }
+      /** @private */
+      _emit(result) {
+        this.emit("checked", result);
+        return result;
+      }
+      /** @private Validation and the built-in checks, before any detector runs. */
+      _prepare(query) {
         const issues = [];
         if (query == null || typeof query !== "string" || query.trim().length === 0) {
           issues.push("Query must be a non-empty string");
-          const result2 = {
-            safe: false,
-            issues,
-            sanitizedQuery: "",
-            injection: { detected: false, matches: [] }
+          return {
+            result: {
+              safe: false,
+              issues,
+              sanitizedQuery: "",
+              injection: { detected: false, matches: [] }
+            }
           };
-          this.emit("checked", result2);
-          return result2;
         }
         const validation = validateInput(query, {
           maxLength: this.config.maxQueryLength
@@ -328,7 +528,7 @@ var require_pre_retrieval_guard = __commonJS({
         }
         const sanitizedQuery = validation.sanitized;
         let injection = { detected: false, matches: [] };
-        if (this.config.enableInjectionDetection) {
+        if (this.config.enableInjectionDetection && this.config.builtIn !== false) {
           const found = detectInjection(sanitizedQuery, {
             patterns: this._customPatterns
           });
@@ -361,26 +561,496 @@ var require_pre_retrieval_guard = __commonJS({
             }
           }
         }
+        return { issues, sanitizedQuery, injection };
+      }
+      /** @private Merge the detectors' findings and emit the result. */
+      _finish({ issues, sanitizedQuery, injection }, detections) {
+        const skip = this.config.onDetectorError === "skip";
+        for (const d of detections) {
+          if (d.error) {
+            if (!skip) {
+              issues.push(`Injection detector "${d.detector}" failed: ${d.error}`);
+            }
+          } else if (d.flagged) {
+            injection = { ...injection, detected: true };
+            const labels = d.labels && d.labels.length ? `: ${d.labels.join(", ")}` : "";
+            issues.push(
+              `Potential prompt injection detected by ${d.detector}${labels}`
+            );
+          }
+        }
         const result = {
           safe: issues.length === 0,
           issues,
           sanitizedQuery,
           injection
         };
-        this.emit("checked", result);
-        return result;
+        if (this._detectors.length > 0) result.detections = detections;
+        return this._emit(result);
       }
     };
+    var CONTEXT = Object.freeze({ stage: "query" });
     module2.exports = { PreRetrievalGuard, DEFAULT_CONFIG };
   }
 });
 
+// src/guardrails/evaluate-detectors.js
+var require_evaluate_detectors = __commonJS({
+  "src/guardrails/evaluate-detectors.js"(exports2, module2) {
+    "use strict";
+    var REPORT_STYLE = `
+:root{--bg:#fff;--fg:#1b1f24;--muted:#57606a;--line:#d0d7de;--ok:#1a7f37;--bad:#cf222e;--chip:#f6f8fa}
+@media (prefers-color-scheme:dark){:root{--bg:#0d1117;--fg:#e6edf3;--muted:#8d96a0;--line:#30363d;--ok:#3fb950;--bad:#f85149;--chip:#161b22}}
+*{box-sizing:border-box}body{margin:0;padding:24px 16px;background:var(--bg);color:var(--fg);font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif}
+main{max-width:1100px;margin:0 auto}h1{font-size:22px;margin:0 0 4px}h2{font-size:17px;margin:28px 0 8px}
+.muted{color:var(--muted)}.status{display:inline-block;padding:2px 10px;border-radius:999px;font-weight:600;font-size:13px}
+.pass{color:var(--ok);border:1px solid var(--ok)}.fail{color:var(--bad);border:1px solid var(--bad)}
+ul.reasons{margin:8px 0;padding-left:20px}.scroll{overflow-x:auto}
+table{border-collapse:collapse;width:100%;font-size:14px}th,td{border-bottom:1px solid var(--line);padding:6px 8px;text-align:left;vertical-align:top}
+th{color:var(--muted);font-weight:600}td.num,th.num{text-align:right;font-variant-numeric:tabular-nums}
+code{background:var(--chip);padding:1px 5px;border-radius:4px;font-size:13px}`;
+    var esc = (text) => String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+    var KINDS = ["injection", "pii"];
+    var MAX_IDS = 50;
+    var Z = 1.96;
+    function validateDetectorCases(cases) {
+      if (!Array.isArray(cases) || cases.length === 0) {
+        throw new TypeError("cases must be a non-empty array");
+      }
+      const ids = /* @__PURE__ */ new Set();
+      return cases.map((c, i) => {
+        const where = `case ${i + 1}${c && c.id != null ? ` ("${c.id}")` : ""}`;
+        if (!c || typeof c !== "object") {
+          throw new TypeError(`${where} is not an object`);
+        }
+        if (!KINDS.includes(c.kind)) {
+          throw new TypeError(`${where}: kind must be "injection" or "pii"`);
+        }
+        if (typeof c.text !== "string") {
+          throw new TypeError(`${where}: text must be a string`);
+        }
+        if (c.spans !== void 0) {
+          if (c.kind !== "pii") {
+            throw new TypeError(`${where}: only pii cases take spans`);
+          }
+          if (!Array.isArray(c.spans) || !c.spans.every(
+            (s) => s && Number.isInteger(s.start) && Number.isInteger(s.end) && s.start >= 0 && s.end > s.start && s.end <= c.text.length
+          )) {
+            throw new TypeError(
+              `${where}: spans must be [{ label, start, end }] inside the text`
+            );
+          }
+        } else if (typeof c.flagged !== "boolean") {
+          throw new TypeError(
+            `${where}: needs flagged: true | false${c.kind === "pii" ? ", or spans" : ""}`
+          );
+        }
+        if (c.tags !== void 0 && !Array.isArray(c.tags)) {
+          throw new TypeError(`${where}: tags must be an array of strings`);
+        }
+        const id = c.id != null ? String(c.id) : String(i + 1);
+        if (ids.has(id)) throw new TypeError(`${where}: duplicate id "${id}"`);
+        ids.add(id);
+        return { ...c, id, tags: (c.tags || []).map(String) };
+      });
+    }
+    function wilson(k, n) {
+      if (n === 0) return null;
+      const p = k / n;
+      const denom = 1 + Z * Z / n;
+      const centre = (p + Z * Z / (2 * n)) / denom;
+      const half = Z * Math.sqrt(p * (1 - p) / n + Z * Z / (4 * n * n)) / denom;
+      return [round(Math.max(0, centre - half)), round(Math.min(1, centre + half))];
+    }
+    var round = (x) => Number(x.toFixed(4));
+    var ratio = (k, n) => n === 0 ? null : round(k / n);
+    function confusionMetrics({ tp, fp, fn, tn }) {
+      const precision = ratio(tp, tp + fp);
+      const recall = ratio(tp, tp + fn);
+      const f1 = ratio(2 * tp, 2 * tp + fp + fn);
+      return {
+        cases: tp + fp + fn + tn,
+        tp,
+        fp,
+        fn,
+        tn,
+        precision,
+        recall,
+        f1,
+        accuracy: ratio(tp + tn, tp + fp + fn + tn),
+        precisionInterval: wilson(tp, tp + fp),
+        recallInterval: wilson(tp, tp + fn)
+      };
+    }
+    var overlaps = (a, b) => a.start < b.end && b.start < a.end;
+    function locate(matches, text) {
+      const used = /* @__PURE__ */ new Set();
+      const out = [];
+      for (const m of matches) {
+        if (Number.isInteger(m.start) && Number.isInteger(m.end)) {
+          out.push(m);
+          continue;
+        }
+        if (!m.text) continue;
+        let from = 0;
+        let at = text.indexOf(m.text, from);
+        while (at !== -1 && used.has(at)) {
+          from = at + 1;
+          at = text.indexOf(m.text, from);
+        }
+        if (at === -1) continue;
+        used.add(at);
+        out.push({ ...m, start: at, end: at + m.text.length });
+      }
+      return out;
+    }
+    async function mapLimit(items, limit, fn) {
+      const results = new Array(items.length);
+      let next = 0;
+      const workers = Array.from(
+        { length: Math.min(limit, items.length) },
+        async () => {
+          while (next < items.length) {
+            const i = next++;
+            results[i] = await fn(items[i], i);
+          }
+        }
+      );
+      await Promise.all(workers);
+      return results;
+    }
+    async function runOne(detector, c, signal) {
+      if (signal && signal.aborted) throw signal.reason || new Error("Aborted");
+      const stage = c.stage || (c.kind === "pii" ? "output" : "query");
+      try {
+        const raw = await detector.detect(c.text, { stage, signal });
+        const r = raw && typeof raw === "object" ? raw : { flagged: Boolean(raw) };
+        return {
+          flagged: Boolean(r.flagged),
+          matches: Array.isArray(r.matches) ? r.matches.filter((m) => m && typeof m === "object") : []
+        };
+      } catch (error) {
+        if (signal && signal.aborted) throw error;
+        return { error: String(error && error.message || error) };
+      }
+    }
+    function scoreDetector(detector, cases, outcomes, covered) {
+      const counts = { tp: 0, fp: 0, fn: 0, tn: 0 };
+      const byTag = {};
+      const missed = [];
+      const falseAlarms = [];
+      const failed = [];
+      const spanTotals = { predicted: 0, matched: 0 };
+      const byLabel = {};
+      const byDetectorLabel = {};
+      let spanCases = 0;
+      cases.forEach((c, i) => {
+        const o = outcomes[i];
+        if (o.error) {
+          failed.push({ id: c.id, error: o.error });
+          return;
+        }
+        const expected = c.spans ? c.spans.length > 0 : c.flagged;
+        const key = expected ? o.flagged ? "tp" : "fn" : o.flagged ? "fp" : "tn";
+        counts[key]++;
+        for (const tag of c.tags) {
+          byTag[tag] = byTag[tag] || { tp: 0, fp: 0, fn: 0, tn: 0 };
+          byTag[tag][key]++;
+        }
+        if (key === "fn") missed.push(c.id);
+        if (key === "fp") falseAlarms.push(c.id);
+        if (c.spans) {
+          spanCases++;
+          const found = locate(o.matches, c.text);
+          for (const m of found) {
+            const hit = c.spans.some((s) => overlaps(s, m));
+            const label = m.label == null ? "(none)" : String(m.label);
+            byDetectorLabel[label] = byDetectorLabel[label] || {
+              predicted: 0,
+              matched: 0
+            };
+            byDetectorLabel[label].predicted++;
+            spanTotals.predicted++;
+            if (hit) {
+              byDetectorLabel[label].matched++;
+              spanTotals.matched++;
+            }
+          }
+          for (const s of c.spans) {
+            const label = s.label == null ? "(none)" : String(s.label);
+            byLabel[label] = byLabel[label] || { gold: 0, found: 0 };
+            byLabel[label].gold++;
+            if (found.some((m) => overlaps(s, m))) byLabel[label].found++;
+          }
+        }
+      });
+      const result = {
+        kind: detector.kind,
+        ...confusionMetrics(counts),
+        errors: failed.length,
+        byTag: Object.fromEntries(
+          Object.entries(byTag).sort(([a], [b]) => a.localeCompare(b)).map(([tag, t]) => [tag, confusionMetrics(t)])
+        ),
+        missed: missed.slice(0, MAX_IDS),
+        falseAlarms: falseAlarms.slice(0, MAX_IDS),
+        failed: failed.slice(0, MAX_IDS)
+      };
+      if (spanCases > 0) {
+        const inScope = Object.entries(byLabel).filter(
+          ([label]) => !covered || covered.includes(label)
+        );
+        const gold = inScope.reduce((n, [, l]) => n + l.gold, 0);
+        const foundSpans = inScope.reduce((n, [, l]) => n + l.found, 0);
+        result.spans = {
+          cases: spanCases,
+          predicted: spanTotals.predicted,
+          matched: spanTotals.matched,
+          precision: ratio(spanTotals.matched, spanTotals.predicted),
+          precisionInterval: wilson(spanTotals.matched, spanTotals.predicted),
+          ...covered && { coveredLabels: covered },
+          gold,
+          found: foundSpans,
+          recall: ratio(foundSpans, gold),
+          recallInterval: wilson(foundSpans, gold),
+          byLabel: Object.fromEntries(
+            Object.entries(byLabel).sort(([, a], [, b]) => b.gold - a.gold).map(([label, l]) => [
+              label,
+              {
+                gold: l.gold,
+                found: l.found,
+                recall: ratio(l.found, l.gold),
+                covered: covered ? covered.includes(label) : true
+              }
+            ])
+          ),
+          byDetectorLabel: Object.fromEntries(
+            Object.entries(byDetectorLabel).sort(([, a], [, b]) => b.predicted - a.predicted).map(([label, l]) => [
+              label,
+              { ...l, precision: ratio(l.matched, l.predicted) }
+            ])
+          )
+        };
+      }
+      return result;
+    }
+    async function evaluateDetectors(cases, detectors, options = {}) {
+      const { concurrency = 4, coveredLabels, signal } = options;
+      const checked = validateDetectorCases(cases);
+      if (!Array.isArray(detectors) || detectors.length === 0) {
+        throw new TypeError("detectors must be a non-empty array");
+      }
+      const names = /* @__PURE__ */ new Set();
+      for (const d of detectors) {
+        if (!d || typeof d.detect !== "function" || typeof d.name !== "string" || !KINDS.includes(d.kind)) {
+          throw new TypeError(
+            "a detector is { name, kind: 'injection' | 'pii', detect(text, context) }"
+          );
+        }
+        if (names.has(d.name)) {
+          throw new TypeError(`two detectors are named "${d.name}"`);
+        }
+        names.add(d.name);
+      }
+      if (!Number.isInteger(concurrency) || concurrency < 1) {
+        throw new TypeError("concurrency must be a positive integer");
+      }
+      const report = {
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cases: {
+          injection: checked.filter((c) => c.kind === "injection").length,
+          pii: checked.filter((c) => c.kind === "pii").length
+        },
+        detectors: {}
+      };
+      for (const detector of detectors) {
+        const mine = checked.filter((c) => c.kind === detector.kind);
+        if (mine.length === 0) continue;
+        const started = Date.now();
+        const outcomes = await mapLimit(
+          mine,
+          concurrency,
+          (c) => runOne(detector, c, signal)
+        );
+        const covered = Array.isArray(coveredLabels) ? coveredLabels : coveredLabels && coveredLabels[detector.name];
+        report.detectors[detector.name] = {
+          ...scoreDetector(detector, mine, outcomes, covered),
+          msPerCase: round((Date.now() - started) / mine.length)
+        };
+      }
+      return report;
+    }
+    function detectorVerdict(report, min = {}) {
+      const reasons = [];
+      for (const [d, m] of Object.entries(report.detectors)) {
+        if (m.errors > 0) {
+          reasons.push(`${d}: ${m.errors} case(s) failed with an error`);
+        }
+      }
+      for (const [key, minimum] of Object.entries(min)) {
+        const dot = key.indexOf(".");
+        const name = key.slice(0, dot);
+        const path = key.slice(dot + 1).split(".");
+        const entry = report.detectors[name];
+        const actual = entry ? path.reduce((v, k) => v == null ? v : v[k], entry) : void 0;
+        if (typeof actual !== "number") {
+          reasons.push(`${key} was not measured (minimum ${minimum})`);
+        } else if (actual < minimum) {
+          reasons.push(
+            `${key} ${actual.toFixed(3)} is below the minimum ${minimum}`
+          );
+        }
+      }
+      return { passed: reasons.length === 0, reasons };
+    }
+    var fixed = (v) => typeof v === "number" ? v.toFixed(3) : "-";
+    var interval = (i) => i ? `${i[0].toFixed(2)}\u2013${i[1].toFixed(2)}` : "-";
+    var mdCell = (text) => String(text).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+    function tables(report) {
+      const out = [];
+      const main = {
+        title: "Detectors",
+        header: [
+          "Detector",
+          "Kind",
+          "Cases",
+          "TP",
+          "FP",
+          "FN",
+          "TN",
+          "Precision",
+          "Recall",
+          "F1",
+          "Recall 95% CI",
+          "Errors"
+        ],
+        rows: Object.entries(report.detectors).map(([name, m]) => [
+          name,
+          m.kind,
+          m.cases,
+          m.tp,
+          m.fp,
+          m.fn,
+          m.tn,
+          fixed(m.precision),
+          fixed(m.recall),
+          fixed(m.f1),
+          interval(m.recallInterval),
+          m.errors
+        ])
+      };
+      out.push(main);
+      for (const [name, m] of Object.entries(report.detectors)) {
+        const tags = Object.entries(m.byTag);
+        if (tags.length > 0) {
+          out.push({
+            title: `${name} by tag`,
+            header: ["Tag", "Cases", "TP", "FP", "FN", "TN", "Precision", "Recall"],
+            rows: tags.map(([tag, t]) => [
+              tag,
+              t.cases,
+              t.tp,
+              t.fp,
+              t.fn,
+              t.tn,
+              fixed(t.precision),
+              fixed(t.recall)
+            ])
+          });
+        }
+        if (m.spans) {
+          out.push({
+            title: `${name} spans: ${m.spans.predicted} matches, precision ${fixed(m.spans.precision)}; recall ${fixed(m.spans.recall)} on ${m.spans.gold} ${m.spans.coveredLabels ? "covered " : ""}spans`,
+            header: ["Labelled as", "Spans", "Found", "Recall", "Covered"],
+            rows: Object.entries(m.spans.byLabel).map(([label, l]) => [
+              label,
+              l.gold,
+              l.found,
+              fixed(l.recall),
+              l.covered ? "yes" : "no"
+            ])
+          });
+        }
+      }
+      return out;
+    }
+    function renderDetectorReport(report, options = {}) {
+      const { format = "markdown", title = "Guardrail detectors", min } = options;
+      const verdict = detectorVerdict(report, min);
+      const summary = `${report.cases.injection} injection case(s), ${report.cases.pii} PII case(s).`;
+      const sections = tables(report);
+      if (format === "markdown") {
+        const out = [
+          `### ${title}: ${verdict.passed ? "\u2705 Passed" : "\u274C Failed"}`,
+          "",
+          summary,
+          ""
+        ];
+        for (const r of verdict.reasons) out.push(`- ${r}`);
+        if (verdict.reasons.length) out.push("");
+        for (const s of sections) {
+          out.push(`**${mdCell(s.title)}**`, "");
+          out.push(`| ${s.header.join(" | ")} |`);
+          out.push(
+            `| ${s.header.map((_, i) => i === 0 ? "---" : "---:").join(" | ")} |`
+          );
+          for (const row of s.rows) out.push(`| ${row.map(mdCell).join(" | ")} |`);
+          out.push("");
+        }
+        return out.join("\n");
+      }
+      if (format === "html") {
+        const parts = [
+          '<!doctype html><html lang="en"><head><meta charset="utf-8">',
+          '<meta name="viewport" content="width=device-width,initial-scale=1">',
+          `<title>${esc(title)}</title><style>${REPORT_STYLE}</style></head><body><main>`,
+          `<h1>${esc(title)}</h1>`,
+          `<p><span class="status ${verdict.passed ? "pass" : "fail"}">${verdict.passed ? "Passed" : "Failed"}</span> <span class="muted">${esc(summary)} \xB7 ${esc(report.createdAt || "")}</span></p>`
+        ];
+        if (verdict.reasons.length) {
+          parts.push(
+            `<ul class="reasons">${verdict.reasons.map((r) => `<li>${esc(r)}</li>`).join("")}</ul>`
+          );
+        }
+        for (const s of sections) {
+          parts.push(
+            `<h2>${esc(s.title)}</h2><div class="scroll"><table><thead><tr>`
+          );
+          parts.push(
+            s.header.map((h, i) => `<th${i === 0 ? "" : ' class="num"'}>${esc(h)}</th>`).join("")
+          );
+          parts.push("</tr></thead><tbody>");
+          for (const row of s.rows) {
+            parts.push(
+              `<tr>${row.map((v, i) => `<td${i === 0 ? "" : ' class="num"'}>${i === 0 ? `<code>${esc(v)}</code>` : esc(v)}</td>`).join("")}</tr>`
+            );
+          }
+          parts.push("</tbody></table></div>");
+        }
+        parts.push("</main></body></html>");
+        return parts.join("");
+      }
+      throw new TypeError(`format must be "markdown" or "html", not "${format}"`);
+    }
+    module2.exports = {
+      evaluateDetectors,
+      validateDetectorCases,
+      detectorVerdict,
+      renderDetectorReport
+    };
+  }
+});
+
 // src/guardrails/retrieval-guard.js
 var require_retrieval_guard = __commonJS({
   "src/guardrails/retrieval-guard.js"(exports2, module2) {
     "use strict";
     var { EventEmitter } = require("events");
     var { detectInjection } = require_injection_detector();
+    var {
+      resolveDetectors,
+      runDetectorsSync,
+      runDetectorsAsync
+    } = require_detectors();
     var DEFAULT_CONFIG = {
       minRelevanceScore: 0,
       maxAgeDays: 0,
@@ -402,10 +1072,19 @@ var require_retrieval_guard = __commonJS({
        * @param {boolean} [options.detectInjection=false] - Scan document text for prompt injection
        * @param {'remove'|'flag'} [options.injectionAction='remove'] - Remove flagged documents or keep and mark them
        * @param {RegExp[]} [options.injectionPatterns=[]] - Extra injection patterns for the scan
+       * @param {Array<object>} [options.detectors=[]] - Injection detectors to run on each document's text too, when detectInjection is on (see ./detectors); async ones need filterAsync(), which calls them once per document, concurrently
+       * @param {boolean} [options.builtIn=true] - false: use only `detectors` for the injection scan
+       * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws counts as a finding ('block': the document is removed or flagged) or is ignored ('skip')
        */
       constructor(options = {}) {
         super();
         this.config = { ...DEFAULT_CONFIG, ...options };
+        this._detectors = resolveDetectors("RetrievalGuard", "injection", options);
+        if (this._detectors.length > 0 && this.config.detectInjection !== true) {
+          throw new TypeError(
+            "RetrievalGuard: detectors run in the injection scan; set detectInjection: true"
+          );
+        }
       }
       /**
        * Filter retrieval results based on configured guards.
@@ -421,17 +1100,59 @@ var require_retrieval_guard = __commonJS({
        * @fires RetrievalGuard#filtered
        */
       filter(results, context = {}) {
+        const state = this._screen(results, context);
+        if (state.output) return state.output;
+        const detections = state.scan.map(
+          (i) => this._detectors.length > 0 ? runDetectorsSync(
+            this._detectors,
+            documentText(state.results[i]),
+            { stage: "document", document: state.results[i] },
+            { guard: "RetrievalGuard", asyncMethod: "filterAsync" }
+          ) : []
+        );
+        return this._finish(state, detections);
+      }
+      /**
+       * filter() for async detectors, such as a classifier model or a service. Each
+       * document that reaches the injection scan is checked by every detector,
+       * all concurrently.
+       *
+       * @param {Array<object>} results
+       * @param {object} [context={}]
+       * @param {object} [options]
+       * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+       * @returns {Promise<ReturnType<RetrievalGuard['filter']>>}
+       */
+      async filterAsync(results, context = {}, { signal } = {}) {
+        const state = this._screen(results, context);
+        if (state.output) return state.output;
+        const detections = await Promise.all(
+          state.scan.map(
+            (i) => this._detectors.length > 0 ? runDetectorsAsync(this._detectors, documentText(state.results[i]), {
+              stage: "document",
+              document: state.results[i],
+              ...signal && { signal }
+            }) : []
+          )
+        );
+        return this._finish(state, detections);
+      }
+      /**
+       * @private Relevance, freshness and ACL, then which documents go on to
+       * the injection scan.
+       */
+      _screen(results, context) {
         if (!Array.isArray(results)) {
-          const output2 = { results: [], removed: [], metadata: { reasons: {} } };
-          this.emit("filtered", output2);
-          return output2;
+          const output = { results: [], removed: [], metadata: { reasons: {} } };
+          this.emit("filtered", output);
+          return { output };
         }
-        const kept = [];
-        const removed = [];
         const reasons = {};
+        const dropped = new Array(results.length).fill(false);
+        const scan = [];
         const now = Date.now();
         const maxAgeMs = this.config.maxAgeDays > 0 ? this.config.maxAgeDays * 24 * 60 * 60 * 1e3 : 0;
-        for (const result of results) {
+        results.forEach((result, i) => {
           let dominated = false;
           const doc = result.metadata || result.doc || result;
           if (this.config.minRelevanceScore > 0) {
@@ -465,29 +1186,50 @@ var require_retrieval_guard = __commonJS({
               }
             }
           }
-          if (!dominated && this.config.detectInjection) {
-            const text = documentText(result);
-            const found = detectInjection(text, {
-              patterns: this.config.injectionPatterns
-            });
-            if (found.detected) {
-              reasons.injection = (reasons.injection || 0) + 1;
-              if (this.config.injectionAction === "flag") {
-                kept.push({
-                  ...result,
-                  injection: { detected: true, matches: found.matches }
-                });
-                continue;
-              }
-              dominated = true;
-            }
+          dropped[i] = dominated;
+          if (!dominated && this.config.detectInjection) scan.push(i);
+        });
+        return { results, reasons, dropped, scan };
+      }
+      /** @private 4. Indirect prompt injection in document text (opt-in). */
+      _finish({ results, reasons, dropped, scan }, detections) {
+        const findings = /* @__PURE__ */ new Map();
+        const skip = this.config.onDetectorError === "skip";
+        scan.forEach((i, n) => {
+          const matches = this.config.builtIn === false ? [] : detectInjection(documentText(results[i]), {
+            patterns: this.config.injectionPatterns
+          }).matches;
+          const found = detections[n] || [];
+          const flagged = found.some((d) => d.flagged || d.error && !skip);
+          if (matches.length > 0 || flagged) {
+            findings.set(i, { matches, detections: found });
           }
-          if (dominated) {
+        });
+        const kept = [];
+        const removed = [];
+        results.forEach((result, i) => {
+          const finding = findings.get(i);
+          if (finding) {
+            reasons.injection = (reasons.injection || 0) + 1;
+            if (this.config.injectionAction === "flag") {
+              kept.push({
+                ...result,
+                injection: {
+                  detected: true,
+                  matches: finding.matches,
+                  ...this._detectors.length > 0 && {
+                    detections: finding.detections
+                  }
+                }
+              });
+              return;
+            }
             removed.push(result);
-          } else {
-            kept.push(result);
+            return;
           }
-        }
+          if (dropped[i]) removed.push(result);
+          else kept.push(result);
+        });
         const output = {
           results: kept,
           removed,
@@ -521,18 +1263,19 @@ var require_post_generation_guard = __commonJS({
   "src/guardrails/post-generation-guard.js"(exports2, module2) {
     "use strict";
     var { EventEmitter } = require("events");
+    var {
+      DEFAULT_PII_PATTERNS,
+      resolveDetectors,
+      runDetectorsSync,
+      runDetectorsAsync
+    } = require_detectors();
     var DEFAULT_CONFIG = {
       enablePIIDetection: true,
       enableGroundednessCheck: true,
       groundednessThreshold: 0.3,
       maxResponseLength: 5e4,
       minResponseLength: 0,
-      piiPatterns: {
-        email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
-        phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
-        ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
-        creditCard: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g
-      }
+      piiPatterns: DEFAULT_PII_PATTERNS
     };
     var PostGenerationGuard = class extends EventEmitter {
       /**
@@ -543,9 +1286,13 @@ var require_post_generation_guard = __commonJS({
        * @param {number} [options.maxResponseLength=50000] - Maximum allowed response length
        * @param {number} [options.minResponseLength=0] - Minimum response length
        * @param {object} [options.piiPatterns] - Custom PII regex patterns (merged with defaults)
+       * @param {Array<object>} [options.detectors=[]] - PII detectors to run on the output too (see ./detectors); their matches are redacted. Async ones need checkAsync()
+       * @param {boolean} [options.builtIn=true] - false: use only `detectors`, not the built-in PII patterns
+       * @param {'block'|'skip'} [options.onDetectorError='block'] - A detector that throws makes the output unsafe ('block'; what it would have found can't be redacted) or is ignored ('skip')
        */
       constructor(options = {}) {
         super();
+        this._detectors = resolveDetectors("PostGenerationGuard", "pii", options);
         this.config = { ...DEFAULT_CONFIG, ...options };
         if (options.piiPatterns) {
           this.config.piiPatterns = {
@@ -568,13 +1315,52 @@ var require_post_generation_guard = __commonJS({
        * @fires PostGenerationGuard#checked
        */
       check(output, retrievedDocs = []) {
-        const issues = [];
         if (output == null || typeof output !== "string") {
-          issues.push("Output must be a string");
-          const result2 = { safe: false, issues, sanitizedOutput: "" };
-          this.emit("checked", result2);
-          return result2;
+          return this._invalid();
         }
+        const detections = this._runDetectors() ? runDetectorsSync(this._detectors, output, CONTEXT, {
+          guard: "PostGenerationGuard",
+          asyncMethod: "checkAsync"
+        }) : [];
+        return this._check(output, retrievedDocs, detections);
+      }
+      /**
+       * check() for async detectors, such as a model or a PII service.
+       * Detectors run concurrently.
+       *
+       * @param {string} output
+       * @param {Array<object>} [retrievedDocs=[]]
+       * @param {object} [options]
+       * @param {AbortSignal} [options.signal] - Passed to each detector in its context
+       * @returns {Promise<ReturnType<PostGenerationGuard['check']>>}
+       */
+      async checkAsync(output, retrievedDocs = [], { signal } = {}) {
+        if (output == null || typeof output !== "string") {
+          return this._invalid();
+        }
+        const detections = this._runDetectors() ? await runDetectorsAsync(this._detectors, output, {
+          ...CONTEXT,
+          ...signal && { signal }
+        }) : [];
+        return this._check(output, retrievedDocs, detections);
+      }
+      /** @private */
+      _runDetectors() {
+        return this.config.enablePIIDetection && this._detectors.length > 0;
+      }
+      /** @private 1. The output must be a string. */
+      _invalid() {
+        const result = {
+          safe: false,
+          issues: ["Output must be a string"],
+          sanitizedOutput: ""
+        };
+        this.emit("checked", result);
+        return result;
+      }
+      /** @private */
+      _check(output, retrievedDocs, detections) {
+        const issues = [];
         if (this.config.maxResponseLength > 0 && output.length > this.config.maxResponseLength) {
           issues.push(
             `Output exceeds maximum length of ${this.config.maxResponseLength} characters`
@@ -586,7 +1372,7 @@ var require_post_generation_guard = __commonJS({
           );
         }
         const piiMatches = {};
-        if (this.config.enablePIIDetection) {
+        if (this.config.enablePIIDetection && this.config.builtIn !== false) {
           for (const [name, pattern] of Object.entries(this.config.piiPatterns)) {
             pattern.lastIndex = 0;
             const matches = output.match(pattern);
@@ -598,6 +1384,22 @@ var require_post_generation_guard = __commonJS({
             }
           }
         }
+        const skip = this.config.onDetectorError === "skip";
+        const detected = [];
+        for (const d of detections) {
+          if (d.error) {
+            if (!skip) {
+              issues.push(`PII detector "${d.detector}" failed: ${d.error}`);
+            }
+          } else if (d.flagged) {
+            const texts = d.matches.map((m) => m.text).filter(Boolean);
+            detected.push(...texts);
+            const labels = d.labels && d.labels.length ? ` (${d.labels.join(", ")})` : "";
+            issues.push(
+              `PII detected by ${d.detector}${labels}: ${texts.length} occurrence(s)`
+            );
+          }
+        }
         let groundednessScore;
         if (this.config.enableGroundednessCheck && Array.isArray(retrievedDocs) && retrievedDocs.length > 0) {
           try {
@@ -622,6 +1424,7 @@ var require_post_generation_guard = __commonJS({
             }
           }
         }
+        sanitizedOutput = replaceAll(sanitizedOutput, detected);
         if (this.config.maxResponseLength > 0 && sanitizedOutput.length > this.config.maxResponseLength) {
           sanitizedOutput = sanitizedOutput.substring(
             0,
@@ -636,28 +1439,52 @@ var require_post_generation_guard = __commonJS({
         if (groundednessScore !== void 0) {
           result.groundednessScore = groundednessScore;
         }
+        if (this._detectors.length > 0) {
+          result.detections = detections.map(({ matches, ...d }) => ({
+            ...d,
+            matches: matches.map(({ text, ...m }) => m)
+          }));
+          Object.defineProperty(result, "matchedText", {
+            value: [...new Set(detected)],
+            enumerable: false
+          });
+        }
         this.emit("checked", result);
         return result;
       }
       /**
        * Replace PII matches in arbitrary text with [REDACTED], using the same
        * patterns as check(). Used to scrub text derived from the answer, such as
-       * citation sentences.
+       * citation sentences. Detectors don't run here (they may be async):
+       * pass the strings a check found, `detectedText(result)`, as `matches`
+       * so they are removed too.
        *
        * @param {string} text
+       * @param {string[]} [matches=[]] - Exact strings to redact as well
        * @returns {string}
        */
-      redact(text) {
+      redact(text, matches = []) {
         if (typeof text !== "string" || !this.config.enablePIIDetection) {
           return text;
         }
         let redacted = text;
-        for (const pattern of Object.values(this.config.piiPatterns)) {
-          redacted = redacted.replace(pattern, "[REDACTED]");
+        if (this.config.builtIn !== false) {
+          for (const pattern of Object.values(this.config.piiPatterns)) {
+            redacted = redacted.replace(pattern, "[REDACTED]");
+          }
         }
-        return redacted;
+        return replaceAll(redacted, matches);
       }
     };
+    var CONTEXT = Object.freeze({ stage: "output" });
+    function replaceAll(text, strings) {
+      const unique = [...new Set(strings.filter(Boolean))].sort(
+        (a, b) => b.length - a.length
+      );
+      let out = text;
+      for (const s of unique) out = out.split(s).join("[REDACTED]");
+      return out;
+    }
     module2.exports = { PostGenerationGuard, DEFAULT_CONFIG };
   }
 });
@@ -670,6 +1497,7 @@ var require_guardrails_pipeline = __commonJS({
     var { PreRetrievalGuard } = require_pre_retrieval_guard();
     var { RetrievalGuard } = require_retrieval_guard();
     var { PostGenerationGuard } = require_post_generation_guard();
+    var { detectedText } = require_detectors();
     var DEFAULT_CONFIG = {
       preRetrieval: {},
       // PreRetrievalGuard options, or false to disable
@@ -686,6 +1514,12 @@ var require_guardrails_pipeline = __commonJS({
         removed: filterOutput.removed.map((doc) => ({ id: doc.id }))
       };
     }
+    function withReasons(message, check) {
+      const issues = check && check.issues || [];
+      if (issues.length === 0) return message;
+      const text = issues.map(String).join("; ");
+      return `${message}: ${text.length > 300 ? `${text.slice(0, 297)}...` : text}`;
+    }
     var GuardrailsPipeline = class extends EventEmitter {
       /**
        * @param {object} pipeline - The underlying RAG pipeline (must have a .run() method)
@@ -725,13 +1559,21 @@ var require_guardrails_pipeline = __commonJS({
           postGeneration: null
         };
         let query = input.query;
+        const signal = input.options && input.options.signal;
+        const callOptions = signal ? { signal } : {};
         if (this.preGuard) {
-          guardrails.preRetrieval = this.preGuard.check(query);
+          guardrails.preRetrieval = await this.preGuard.checkAsync(
+            query,
+            callOptions
+          );
           this.emit("preRetrieval", guardrails.preRetrieval);
           if (!guardrails.preRetrieval.safe && this.config.strict) {
             return {
               success: false,
-              error: "Pre-retrieval guard blocked query",
+              error: withReasons(
+                "Pre-retrieval guard blocked query",
+                guardrails.preRetrieval
+              ),
               guardrails
             };
           }
@@ -739,10 +1581,11 @@ var require_guardrails_pipeline = __commonJS({
         }
         let preGenerationFilter = null;
         const filterOptions = this.retrievalGuard ? {
-          filterResults: (docs) => {
-            preGenerationFilter = this.retrievalGuard.filter(
+          filterResults: async (docs) => {
+            preGenerationFilter = await this.retrievalGuard.filterAsync(
               docs,
-              input.context
+              input.context,
+              callOptions
             );
             return preGenerationFilter.results;
           }
@@ -757,7 +1600,11 @@ var require_guardrails_pipeline = __commonJS({
           this.emit("retrieval", guardrails.retrieval);
         } else if (this.retrievalGuard && result.results) {
           guardrails.retrieval = summarizeFilter(
-            this.retrievalGuard.filter(result.results, input.context)
+            await this.retrievalGuard.filterAsync(
+              result.results,
+              input.context,
+              callOptions
+            )
           );
           this.emit("retrieval", guardrails.retrieval);
           result.results = guardrails.retrieval.results;
@@ -770,21 +1617,26 @@ var require_guardrails_pipeline = __commonJS({
           }
         }
         if (this.postGuard && result.answer) {
-          guardrails.postGeneration = this.postGuard.check(
+          guardrails.postGeneration = await this.postGuard.checkAsync(
             result.answer,
-            result.results
+            result.results,
+            callOptions
           );
           this.emit("postGeneration", guardrails.postGeneration);
           if (!guardrails.postGeneration.safe && this.config.strict) {
             return {
               success: false,
-              error: "Post-generation guard flagged output",
+              error: withReasons(
+                "Post-generation guard flagged output",
+                guardrails.postGeneration
+              ),
               guardrails
             };
           }
           result.answer = guardrails.postGeneration.sanitizedOutput;
-          this._redactDeep(result.citations);
-          this._redactDeep(result.evaluation);
+          const found = detectedText(guardrails.postGeneration);
+          this._redactDeep(result.citations, found);
+          this._redactDeep(result.evaluation, found);
         }
         result.guardrails = guardrails;
         return result;
@@ -794,14 +1646,15 @@ var require_guardrails_pipeline = __commonJS({
        * scrub every string in them with the same PII patterns as the answer.
        *
        * @param {*} value - Object, array or string to redact in place
+       * @param {string[]} [matches=[]] - Strings found by PII detectors, redacted too
        * @returns {*} The redacted value
        * @private
        */
-      _redactDeep(value) {
-        if (typeof value === "string") return this.postGuard.redact(value);
+      _redactDeep(value, matches = []) {
+        if (typeof value === "string") return this.postGuard.redact(value, matches);
         if (value && typeof value === "object") {
           for (const key of Object.keys(value)) {
-            value[key] = this._redactDeep(value[key]);
+            value[key] = this._redactDeep(value[key], matches);
           }
         }
         return value;
@@ -817,12 +1670,28 @@ var require_guardrails = __commonJS({
     "use strict";
     var { PreRetrievalGuard } = require_pre_retrieval_guard();
     var { detectInjection } = require_injection_detector();
+    var {
+      patternInjectionDetector,
+      patternPIIDetector,
+      detectedText
+    } = require_detectors();
+    var {
+      evaluateDetectors,
+      detectorVerdict,
+      renderDetectorReport
+    } = require_evaluate_detectors();
     var { RetrievalGuard } = require_retrieval_guard();
     var { PostGenerationGuard } = require_post_generation_guard();
     var { GuardrailsPipeline } = require_guardrails_pipeline();
     module2.exports = {
       PreRetrievalGuard,
       detectInjection,
+      patternInjectionDetector,
+      patternPIIDetector,
+      detectedText,
+      evaluateDetectors,
+      detectorVerdict,
+      renderDetectorReport,
       RetrievalGuard,
       PostGenerationGuard,
       GuardrailsPipeline
@@ -833,6 +1702,8 @@ var require_guardrails = __commonJS({
 // src/package-entry.js
 var mod = require_guardrails();
 var modules = {
+  "guardrails/detectors.js": () => require_detectors(),
+  "guardrails/evaluate-detectors.js": () => require_evaluate_detectors(),
   "guardrails/guardrails-pipeline.js": () => require_guardrails_pipeline(),
   "guardrails/injection-detector.js": () => require_injection_detector(),
   "guardrails/post-generation-guard.js": () => require_post_generation_guard(),

package/dist/index.d.ts

@@ -1 +1 @@
-export { PreRetrievalGuard, detectInjection, RetrievalGuard, PostGenerationGuard, GuardrailsPipeline } from "@devilsdev/rag-core/all-types";
+export { PreRetrievalGuard, detectInjection, patternInjectionDetector, patternPIIDetector, detectedText, evaluateDetectors, detectorVerdict, renderDetectorReport, RetrievalGuard, PostGenerationGuard, GuardrailsPipeline } from "@devilsdev/rag-core/all-types";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const mod = require('./index.cjs');
-export const { PreRetrievalGuard, detectInjection, RetrievalGuard, PostGenerationGuard, GuardrailsPipeline } = mod;
+export const { PreRetrievalGuard, detectInjection, patternInjectionDetector, patternPIIDetector, detectedText, evaluateDetectors, detectorVerdict, renderDetectorReport, RetrievalGuard, PostGenerationGuard, GuardrailsPipeline } = mod;
 export default mod;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devilsdev/rag-guardrails",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Guardrails for RAG: prompt-injection detection and pre-retrieval, retrieval and post-generation guards.",
   "keywords": [
     "rag",
@@ -41,6 +41,6 @@
     "access": "public"
   },
   "dependencies": {
-    "@devilsdev/rag-core": "3.4.0"
+    "@devilsdev/rag-core": "3.5.0"
   }
 }