@anuma/sdk 1.0.0 → 1.1.1

package/dist/{expo/chunk-MJJIYFAX.mjs → react/chunk-GYKJOWEO.mjs}

@@ -10,7 +10,18 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/clientConfig.ts
-var BASE_URL = "https://portal.anuma-dev.ai";
+var DEFAULT_BASE_URL = "https://portal.anuma-dev.ai";
+function readGlobal(key) {
+  if (typeof globalThis === "undefined") return void 0;
+  const value = globalThis[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function resolveBaseUrl() {
+  const fromProcess = typeof process !== "undefined" ? process.env.API_URL || process.env.NEXT_PUBLIC_API_URL || process.env.EXPO_PUBLIC_API_URL : void 0;
+  const fromGlobal = readGlobal("API_URL") ?? readGlobal("NEXT_PUBLIC_API_URL") ?? readGlobal("EXPO_PUBLIC_API_URL");
+  return (fromProcess || fromGlobal || DEFAULT_BASE_URL).replace(/\/+$/, "");
+}
+var BASE_URL = resolveBaseUrl();
 var MCP_R2_DOMAIN = "4cf0e0ea50b97e72386fcf2f92a2d4e8.r2.cloudflarestorage.com";
 var createClientConfig = (config) => ({
   ...config,
@@ -19,6 +30,7 @@ var createClientConfig = (config) => ({
 
 export {
   __decorateClass,
+  resolveBaseUrl,
   BASE_URL,
   MCP_R2_DOMAIN,
   createClientConfig

package/dist/react/chunk-TP6CJZ25.mjs

@@ -0,0 +1,645 @@
+// src/lib/pii/patterns.ts
+function luhnCheck(digits) {
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = parseInt(digits[i], 10);
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+var PII_PATTERNS = [
+  // Email — standard RFC-ish pattern.
+  // Quantifiers are bounded (local-part ≤ 64, domain ≤ 255, TLD ≤ 24 —
+  // all at or above real RFC 5321 limits) so the engine cannot backtrack
+  // quadratically on adversarial input like "a.a.a.a…" with no "@".
+  {
+    category: "EMAIL",
+    regex: /\b[a-zA-Z0-9._%+-]{1,64}@[a-zA-Z0-9.-]{1,255}\.[a-zA-Z]{2,24}\b/g
+  },
+  // SSN — US Social Security Number, dashed form (must run before phone)
+  {
+    category: "SSN",
+    regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+    validate: (match) => {
+      const parts = match.split("-");
+      const area = parseInt(parts[0], 10);
+      return area !== 0 && area !== 666 && area < 900;
+    }
+  },
+  // SSN — dashless or space-separated form. Only redacted with an "SSN" /
+  // "social security" cue nearby: a bare 9-digit run is too ambiguous
+  // (ZIP+4, account numbers, etc.) to redact unconditionally.
+  {
+    category: "SSN",
+    regex: /\b\d{3}[ ]?\d{2}[ ]?\d{4}\b/g,
+    context: /(?:\bssn\b|\bsocial\s+security(?:\s+(?:number|no\.?|#))?\b)[^\d\n]{0,12}$/i,
+    validate: (match) => {
+      const digits = match.replace(/\D/g, "");
+      if (digits.length !== 9) return false;
+      const area = parseInt(digits.slice(0, 3), 10);
+      return area !== 0 && area !== 666 && area < 900;
+    }
+  },
+  // Credit card numbers — 13-19 contiguous digits or groups of 4 separated by spaces/dashes
+  // Must run before phone to avoid partial matches
+  {
+    category: "CREDIT_CARD",
+    regex: /\b\d{4}[\s-]\d{4}[\s-]\d{4}[\s-]\d{1,7}\b|\b\d{13,19}\b/g,
+    validate: (match) => {
+      const digits = match.replace(/\D/g, "");
+      if (digits.length < 13 || digits.length > 19) return false;
+      return luhnCheck(digits);
+    }
+  },
+  // IPv4 addresses (must run before phone to avoid partial matches)
+  {
+    category: "IP_ADDRESS",
+    regex: /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g,
+    validate: (match) => {
+      return match !== "0.0.0.0" && match !== "127.0.0.1" && match !== "255.255.255.255";
+    }
+  },
+  // IPv6 addresses — full and compressed (::) forms. Each alternative requires
+  // either a full 8-group address or a "::" compression, so ordinary
+  // colon-separated text (timestamps like 12:34:56) does not match. Loopback
+  // (::1) and unspecified (::) are excluded.
+  {
+    category: "IP_ADDRESS",
+    regex: /(?:(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?::[0-9a-fA-F]{1,4}){1,6}|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:))/g,
+    validate: (match) => match !== "::1" && match !== "::"
+  },
+  // Phone numbers. The separated form requires separator characters (dashes,
+  // spaces, dots, parens) to avoid matching bare digit sequences that are
+  // actually credit cards, IPs, or years. A second alternative matches E.164
+  // (a leading "+" then 10–15 digits, e.g. +14155552671), which is
+  // unambiguous; a bare 10-digit run with no "+" and no separators is
+  // intentionally not matched to avoid false positives.
+  {
+    category: "PHONE",
+    regex: /(?:\+\d{1,3}[\s.-])?\(?\d{3}\)?[\s.-]\d{3}[\s.-]\d{4}\b|\+\d{10,15}\b/g
+  },
+  // API keys / secrets — long token with a key-like prefix. The validator
+  // requires entropy (at least one digit, or a mix of upper- and lower-case)
+  // so long all-lowercase prose identifiers like
+  // "accessibility_is_important_for_everyone" or
+  // "access-control-list-management-feature" are not redacted. Real keys and
+  // tokens essentially always contain digits or mixed case.
+  {
+    category: "API_KEY",
+    regex: /\b(?:sk|pk|api|key|token|secret|bearer|access)[_-]?[a-zA-Z0-9_-]{20,}\b/gi,
+    validate: (match) => {
+      const hasDigit = /\d/.test(match);
+      const hasMixedCase = /[a-z]/.test(match) && /[A-Z]/.test(match);
+      return hasDigit || hasMixedCase;
+    }
+  },
+  // US street addresses — house number + Title-Case street name + suffix.
+  // Intentionally NOT case-insensitive: the `[A-Z][a-z]+` guard requires
+  // properly-capitalized street words, so "123 main street", "100 MAIN
+  // STREET" and prose like "3 blocks down the road" / "5 minutes to drive"
+  // are not treated as addresses. Whitespace is `[ \t]` only (no newline
+  // spanning), and the suffix must end the segment (punctuation / newline /
+  // end of string) so "Driveway" or "Wayfair" don't match on the suffix.
+  {
+    category: "US_ADDRESS",
+    regex: /\b\d{1,5}[ \t]+(?:[A-Z][a-z]+[ \t]+){1,3}(?:St(?:reet)?|Ave(?:nue)?|Blvd|Boulevard|Dr(?:ive)?|Ln|Lane|Rd|Road|Ct|Court|Pl(?:ace)?|Way|Cir(?:cle)?|Pkwy|Parkway|Hwy|Highway)\.?(?=[\s,.;:!?)]|$)/g,
+    validate: (match) => {
+      return !/^0/.test(match.trim());
+    }
+  },
+  // Dates of birth — common US date formats. Only redacted when a birth-date
+  // cue ("DOB", "born", "birthday", "date of birth") appears just before the
+  // date, so ordinary calendar dates ("meeting 12/25/2024", deadlines,
+  // invoices) are left intact for the model. A calendar validator also rejects
+  // impossible dates like 02/31/1990.
+  {
+    category: "DATE_OF_BIRTH",
+    regex: /\b(?:(?:0?[1-9]|1[0-2])[/-](?:0?[1-9]|[12]\d|3[01])[/-](?:19|20)\d{2})\b/g,
+    context: /(?:\bdob\b|\bd\.?o\.?b\.?|\bborn\b|\bbirth\s?date\b|\bbirthdate\b|\bbirthday\b|\bdate\s+of\s+birth\b)[^\d\n]{0,12}$/i,
+    validate: (match) => {
+      const m = match.match(/(\d{1,2})[/-](\d{1,2})[/-](\d{4})/);
+      if (!m) return false;
+      const month = parseInt(m[1], 10);
+      const day = parseInt(m[2], 10);
+      const year = parseInt(m[3], 10);
+      const isLeap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+      const daysInMonth = [31, isLeap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+      return month >= 1 && month <= 12 && day >= 1 && day <= daysInMonth[month - 1];
+    }
+  }
+];
+
+// src/lib/pii/redactor.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isWordChar(ch) {
+  return /[A-Za-z0-9_]/.test(ch) || ch.charCodeAt(0) > 127;
+}
+var PiiRedactor = class {
+  constructor(options = {}) {
+    /** Maps original PII value → placeholder tag. */
+    this.valueToPlaceholder = /* @__PURE__ */ new Map();
+    /** Maps placeholder tag → original PII value (reverse lookup for de-anonymization). */
+    this.placeholderToValue = /* @__PURE__ */ new Map();
+    /** Next index per category for placeholder numbering. */
+    this.categoryCounters = /* @__PURE__ */ new Map();
+    /**
+     * Matches any placeholder-shaped token for this redactor's categories —
+     * bracketed `[EMAIL_1]` OR bare `EMAIL_1`, case-insensitive — capturing the
+     * body. Drives {@link restoreForStorage}: the extraction / consolidation
+     * models echo placeholders mangled (brackets dropped, re-cased), and a single
+     * pass with this matcher restores the assigned ones and flags the rest in one
+     * go. Built lazily from the union of pattern categories AND any categories
+     * minted at runtime (e.g. NER `PERSON`/`LOCATION`/`ORG`): `undefined` = stale
+     * (rebuild on next use), `null` = built but there are no categories.
+     */
+    this.storagePattern = void 0;
+    /**
+     * Cached body→value lookups for {@link restoreForStorage}, built lazily from
+     * the assigned placeholders and invalidated on each mint. `exact` is keyed by
+     * the literal body (collision-proof); `ci` by upper-cased body for re-cased
+     * echoes, minus any `ciCollisions` where two distinct bodies share a form.
+     */
+    this.storageLookup = null;
+    /** Whether the non-text-content bypass warning has already been emitted. */
+    this.warnedNonText = false;
+    /** Whether the NER-detector-failure warning has already been emitted. */
+    this.warnedNerFailure = false;
+    this.nerDetector = options.nerDetector;
+    if (options.patterns) {
+      this.patterns = options.patterns;
+    } else {
+      let base = PII_PATTERNS;
+      if (options.excludeCategories?.length) {
+        const excluded = new Set(options.excludeCategories);
+        base = base.filter((p) => !excluded.has(p.category));
+      }
+      this.patterns = options.extraPatterns ? [...base, ...options.extraPatterns] : base;
+    }
+    this.patternCategories = [...new Set(this.patterns.map((p) => String(p.category)))];
+  }
+  /**
+   * Build the {@link storagePattern} from the union of pattern categories and
+   * any categories minted at runtime (NER entities arrive only when redaction
+   * runs, so this can't be fixed at construction). Bracketed `[EMAIL_1]` OR
+   * bare `EMAIL_1`, capturing the body, case-insensitive, global. `\d+` (not a
+   * fixed body) spans any index; `\b` on the bare arm keeps it off prose like
+   * "email 1 of 3".
+   */
+  buildStoragePattern() {
+    const categories = [.../* @__PURE__ */ new Set([...this.patternCategories, ...this.categoryCounters.keys()])];
+    if (categories.length === 0) return null;
+    const categoryAlt = categories.sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
+    return new RegExp(`\\[((?:${categoryAlt})_\\d+)\\]|\\b((?:${categoryAlt})_\\d+)\\b`, "gi");
+  }
+  /**
+   * Returns the current number of unique PII values tracked.
+   */
+  get size() {
+    return this.valueToPlaceholder.size;
+  }
+  /**
+   * Returns a snapshot of all placeholder → original value mappings.
+   * Useful for debugging or UI display. This is a copy — mutating it (or
+   * later redactions) does not affect the returned map and vice versa.
+   */
+  getMappings() {
+    return new Map(this.placeholderToValue);
+  }
+  /**
+   * Get or create a placeholder for a PII value.
+   * The same value always gets the same placeholder within a redactor instance.
+   */
+  getPlaceholder(category, value) {
+    const normalizedValue = value.trim();
+    const existing = this.valueToPlaceholder.get(normalizedValue);
+    if (existing) return existing;
+    const existingCount = this.categoryCounters.get(category);
+    const count = (existingCount ?? 0) + 1;
+    this.categoryCounters.set(category, count);
+    if (existingCount === void 0) this.storagePattern = void 0;
+    const placeholder = `[${category}_${count}]`;
+    this.valueToPlaceholder.set(normalizedValue, placeholder);
+    this.placeholderToValue.set(placeholder, normalizedValue);
+    this.storageLookup = null;
+    return placeholder;
+  }
+  /**
+   * Find all matches of a single pattern in `text`, applying its `validate` and
+   * `context` guards. Matches are non-overlapping and ascending (the global
+   * regex advances `lastIndex` past each match). Shared by the sync {@link scan}
+   * (sequential, per-pattern) and the async {@link collectRegexSpans} (span)
+   * paths so the detection rules live in exactly one place.
+   */
+  findMatches(text, pattern) {
+    const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+    const found = [];
+    let m;
+    while ((m = regex.exec(text)) !== null) {
+      const value = m[0];
+      if (pattern.validate && !pattern.validate(value)) continue;
+      if (pattern.context) {
+        const before = text.slice(Math.max(0, m.index - 40), m.index);
+        if (!pattern.context.test(before)) continue;
+      }
+      found.push({ match: value, index: m.index });
+    }
+    return found;
+  }
+  /**
+   * Scan text for PII and rebuild it, replacing each match with whatever
+   * `makeReplacement(category, value)` returns. Shared by `redactText`
+   * (numbered, stateful placeholders) and `maskText` (unnumbered, stateless).
+   *
+   * Patterns are applied sequentially: each scans the text already rewritten by
+   * earlier patterns, so an earlier (more specific) pattern claims a region
+   * before a later one can — placeholders are inert and match no pattern.
+   */
+  scan(text, makeReplacement) {
+    const matches = [];
+    let redacted = text;
+    for (const pattern of this.patterns) {
+      const found = this.findMatches(redacted, pattern);
+      if (found.length === 0) continue;
+      let result = "";
+      let cursor = 0;
+      for (const { match, index } of found) {
+        const placeholder = makeReplacement(pattern.category, match);
+        matches.push({ category: pattern.category, original: match, placeholder });
+        result += redacted.slice(cursor, index) + placeholder;
+        cursor = index + match.length;
+      }
+      result += redacted.slice(cursor);
+      redacted = result;
+    }
+    return { text: redacted, matches };
+  }
+  /**
+   * Scan and redact PII from a single text string, using numbered, reversible
+   * placeholders ([EMAIL_1], …) tracked on this instance.
+   */
+  redactText(text) {
+    return this.scan(text, (category, value) => this.getPlaceholder(category, value));
+  }
+  /**
+   * Mask PII with unnumbered, NON-reversible tokens ([EMAIL], [SSN], …) without
+   * mutating this instance's state. Use for one-way purposes where the value is
+   * never restored — notably embedding inputs: it keeps real PII off the
+   * embeddings endpoint while staying deterministic, so the same content always
+   * masks identically and search stays consistent across conversations.
+   */
+  maskText(text) {
+    return this.scan(text, (category) => `[${category}]`).text;
+  }
+  // ───────────────────────────────────────────────────────────────────────
+  // Async (regex + NER) path. Mirrors the sync API but additionally folds in
+  // an optional {@link NerDetector}'s spans. When no detector is configured,
+  // each async method delegates to its sync counterpart and is byte-for-byte
+  // identical — so it is a safe drop-in.
+  // ───────────────────────────────────────────────────────────────────────
+  /** All regex matches as spans on the ORIGINAL text (priority 0). Uses the
+   *  same {@link findMatches} guards as the sync scan. */
+  collectRegexSpans(text) {
+    const spans = [];
+    this.patterns.forEach((pattern, patternIndex) => {
+      for (const { match, index } of this.findMatches(text, pattern)) {
+        spans.push({
+          start: index,
+          end: index + match.length,
+          category: pattern.category,
+          priority: 0,
+          order: patternIndex
+        });
+      }
+    });
+    return spans;
+  }
+  /**
+   * Normalize raw NER spans: clamp to the text bounds, drop empty/categoryless
+   * spans, and snap each to whole-word boundaries. Snapping prevents a detector
+   * that tagged only part of a word (a common WordPiece artifact — e.g. "Strip"
+   * of "Stripe") from producing a corrupting partial placeholder like
+   * `[ORG_1]e`.
+   */
+  normalizeNerSpans(text, raw) {
+    if (!Array.isArray(raw)) return [];
+    const out = [];
+    raw.forEach((s, i) => {
+      if (!Number.isFinite(s.start) || !Number.isFinite(s.end)) return;
+      let start = Math.max(0, Math.min(Math.trunc(s.start), text.length));
+      let end = Math.max(0, Math.min(Math.trunc(s.end), text.length));
+      if (end <= start) return;
+      while (start > 0 && isWordChar(text[start - 1])) start--;
+      while (end < text.length && isWordChar(text[end])) end++;
+      const category = String(s.category ?? "").trim();
+      if (!category) return;
+      out.push({ start, end, category, priority: 1, order: i });
+    });
+    return out;
+  }
+  /** Run the configured detector defensively: failures degrade to regex-only
+   *  (fail-open on detection, not on protection) with a one-time warning. */
+  async detectNerSpans(text) {
+    if (!this.nerDetector) return [];
+    try {
+      return this.normalizeNerSpans(text, await this.nerDetector.detect(text));
+    } catch (err) {
+      this.warnNerFailure(err);
+      return [];
+    }
+  }
+  /**
+   * Resolve overlaps by placing higher-priority spans first and dropping any
+   * span that overlaps one already placed. Regex (priority 0) is placed before
+   * NER (priority 1), and within regex by ascending pattern index — so regex
+   * always wins on overlap and the regex-only result reproduces the sync scan's
+   * sequential "earlier pattern wins". O(n²) but n (spans per message) is tiny.
+   *
+   * The returned spans stay in `(priority, order, start)` order — i.e. mint
+   * order — which {@link rebuildSpans} relies on.
+   */
+  resolveOverlaps(spans) {
+    const ordered = [...spans].sort(
+      (a, b) => a.priority - b.priority || a.order - b.order || a.start - b.start
+    );
+    const placed = [];
+    for (const s of ordered) {
+      if (!placed.some((p) => s.start < p.end && p.start < s.end)) placed.push(s);
+    }
+    return placed;
+  }
+  /**
+   * Rebuild `text` from resolved (non-overlapping) spans. `spans` must arrive in
+   * mint order — `(priority, order, start)`, as {@link resolveOverlaps} returns —
+   * so placeholders are MINTED by iterating it directly (regex categories first,
+   * in pattern then document order, matching the sync scan's numbering). The
+   * string is then EMITTED in document order.
+   */
+  rebuildSpans(text, spans, makeReplacement) {
+    const placeholderByStart = /* @__PURE__ */ new Map();
+    const matches = [];
+    for (const s of spans) {
+      const value = text.slice(s.start, s.end);
+      const placeholder = makeReplacement(s.category, value);
+      placeholderByStart.set(s.start, placeholder);
+      matches.push({ category: s.category, original: value, placeholder });
+    }
+    const emitOrder = [...spans].sort((a, b) => a.start - b.start);
+    let result = "";
+    let cursor = 0;
+    for (const s of emitOrder) {
+      result += text.slice(cursor, s.start) + (placeholderByStart.get(s.start) ?? "");
+      cursor = s.end;
+    }
+    result += text.slice(cursor);
+    return { text: result, matches };
+  }
+  /** Merge regex + NER spans for `text` into a resolved, non-overlapping set. */
+  async detectAllSpans(text) {
+    const nerPromise = this.detectNerSpans(text);
+    const regexSpans = this.collectRegexSpans(text);
+    const ner = await nerPromise;
+    return this.resolveOverlaps([...regexSpans, ...ner]);
+  }
+  /**
+   * Async counterpart to {@link redactText}: redacts structured PII (regex) AND
+   * unstructured PII (the configured {@link NerDetector}) with numbered,
+   * reversible placeholders. With no detector, identical to `redactText`.
+   */
+  async redactTextAsync(text) {
+    if (!this.nerDetector) return this.redactText(text);
+    const spans = await this.detectAllSpans(text);
+    return this.rebuildSpans(
+      text,
+      spans,
+      (category, value) => this.getPlaceholder(category, value)
+    );
+  }
+  /**
+   * Async counterpart to {@link maskText}: stateless `[CATEGORY]` masking over
+   * regex + NER matches. With no detector, identical to `maskText`.
+   */
+  async maskTextAsync(text) {
+    if (!this.nerDetector) return this.maskText(text);
+    const spans = await this.detectAllSpans(text);
+    return this.rebuildSpans(text, spans, (category) => `[${category}]`).text;
+  }
+  /**
+   * Async counterpart to {@link redactMessages}. Text parts are redacted
+   * sequentially so placeholder numbering stays deterministic across the
+   * conversation. With no detector, identical to `redactMessages`.
+   */
+  async redactMessagesAsync(messages) {
+    if (!this.nerDetector) return this.redactMessages(messages);
+    const allMatches = [];
+    const redactedMessages = [];
+    for (const msg of messages) {
+      if (!msg.content) {
+        redactedMessages.push(msg);
+        continue;
+      }
+      const newContent = [];
+      for (const part of msg.content) {
+        if (part.type === "text" && part.text) {
+          const result = await this.redactTextAsync(part.text);
+          allMatches.push(...result.matches);
+          newContent.push(result.matches.length > 0 ? { ...part, text: result.text } : part);
+        } else {
+          if (part.type !== "text") this.warnNonTextBypass();
+          newContent.push(part);
+        }
+      }
+      redactedMessages.push({ ...msg, content: newContent });
+    }
+    return { messages: redactedMessages, matches: allMatches };
+  }
+  /**
+   * Redact PII from an array of LlmapiMessage objects.
+   * Returns new message objects — originals are not mutated.
+   *
+   * All roles' text content is redacted, not just user/system: tool results
+   * can return PII fetched from external systems, and assistant history is
+   * persisted with original (de-anonymized) values, so both must be re-redacted
+   * before they go back over the wire. Placeholders the model already emitted
+   * are inert here (they don't match any PII pattern), so re-redaction is safe.
+   */
+  redactMessages(messages) {
+    const allMatches = [];
+    const redactedMessages = messages.map((msg) => {
+      if (!msg.content) return msg;
+      const newContent = msg.content.map((part) => {
+        if (part.type === "text" && part.text) {
+          const result = this.redactText(part.text);
+          allMatches.push(...result.matches);
+          if (result.matches.length > 0) {
+            return { ...part, text: result.text };
+          }
+        } else if (part.type !== "text") {
+          this.warnNonTextBypass();
+        }
+        return part;
+      });
+      return { ...msg, content: newContent };
+    });
+    return { messages: redactedMessages, matches: allMatches };
+  }
+  /** Emit the non-text bypass warning at most once per redactor instance. */
+  warnNonTextBypass() {
+    if (this.warnedNonText) return;
+    this.warnedNonText = true;
+    console.warn(
+      "[PiiRedactor] A message contains non-text content (images, files, or attachments) that is NOT scanned for PII \u2014 only text parts are redacted."
+    );
+  }
+  /** Emit the NER-detector-failure warning at most once per redactor instance. */
+  warnNerFailure(err) {
+    if (this.warnedNerFailure) return;
+    this.warnedNerFailure = true;
+    console.warn(
+      "[PiiRedactor] The NER detector threw; falling back to regex-only redaction for this call's unstructured PII. The detector is still retried on subsequent calls; this warning is emitted only once.",
+      err
+    );
+  }
+  /**
+   * Restore original PII values in text that contains placeholders.
+   * Used to de-anonymize LLM responses before displaying to the user.
+   *
+   * Exact: matches the literal `[EMAIL_1]` form only. The storage paths use
+   * {@link restoreForStorage} instead, which tolerates the mangled echoes the
+   * extraction models produce.
+   */
+  deAnonymize(text) {
+    if (!text.includes("[")) return text;
+    let restored = text;
+    for (const [placeholder, original] of this.placeholderToValue) {
+      if (restored.includes(placeholder)) {
+        restored = restored.split(placeholder).join(original);
+      }
+    }
+    return restored;
+  }
+  /**
+   * De-anonymize for PERSISTENCE (auto-extraction / consolidation), tolerant of
+   * the ways the extraction models mangle a placeholder when echoing it back:
+   * dropped brackets (`EMAIL_1`) and changed case (`email_1` / `Email_1`).
+   *
+   * Returns the restored text plus `unresolved` — true when a placeholder-shaped
+   * token for one of this redactor's categories was NOT assigned during
+   * redaction (a model hallucination, or an ambiguous re-cased collision).
+   * Callers drop/degrade such facts so an opaque token never reaches the vault.
+   *
+   * One left-to-right pass over the ORIGINAL text. Two properties matter:
+   * - a restored value is never re-scanned — so a real value that happens to
+   *   contain a `<CATEGORY>_<n>` substring (e.g. the email `ssn_1@example.com`,
+   *   or an API key containing `EMAIL_1`) is neither corrupted nor false-flagged;
+   * - `unresolved` is derived from the lookup miss during this pass, not from a
+   *   regex re-scan of the output — so it can't trip over a restored value.
+   */
+  restoreForStorage(text) {
+    if (this.storagePattern === void 0) this.storagePattern = this.buildStoragePattern();
+    if (!this.storagePattern || this.placeholderToValue.size === 0) {
+      return { text, unresolved: false };
+    }
+    this.storageLookup ?? (this.storageLookup = this.buildStorageLookup());
+    const { exact, ci, ciCollisions } = this.storageLookup;
+    let unresolved = false;
+    const restored = text.replace(
+      this.storagePattern,
+      (match, bracketed, bare) => {
+        const body = bracketed ?? bare ?? "";
+        const exactHit = exact.get(body);
+        if (exactHit !== void 0) return exactHit;
+        const key = body.toUpperCase();
+        if (!ciCollisions.has(key)) {
+          const ciHit = ci.get(key);
+          if (ciHit !== void 0) return ciHit;
+        }
+        unresolved = true;
+        return match;
+      }
+    );
+    return { text: restored, unresolved };
+  }
+  /**
+   * Build the {@link restoreForStorage} body→value lookups from the assigned
+   * placeholders. `exact` (literal body) is collision-proof; `ci` (upper-cased
+   * body) handles re-cased echoes, except where two distinct bodies share an
+   * upper-cased form — those are recorded in `ciCollisions` so a re-cased echo
+   * of them is left unresolved rather than resolved to the wrong value.
+   */
+  buildStorageLookup() {
+    const exact = /* @__PURE__ */ new Map();
+    const ci = /* @__PURE__ */ new Map();
+    const ciCollisions = /* @__PURE__ */ new Set();
+    for (const [placeholder, value] of this.placeholderToValue) {
+      const body = placeholder.slice(1, -1);
+      exact.set(body, value);
+      const key = body.toUpperCase();
+      if (ci.has(key) && ci.get(key) !== value) ciCollisions.add(key);
+      else ci.set(key, value);
+    }
+    return { exact, ci, ciCollisions };
+  }
+  /**
+   * Reset all state. Useful for testing or when starting a fresh conversation.
+   */
+  clear() {
+    this.valueToPlaceholder.clear();
+    this.placeholderToValue.clear();
+    this.categoryCounters.clear();
+    this.storageLookup = null;
+    this.storagePattern = void 0;
+    this.warnedNonText = false;
+    this.warnedNerFailure = false;
+  }
+};
+function isPiiRedactor(value) {
+  return typeof value === "object" && value !== null && typeof value.redactMessages === "function" && typeof value.deAnonymize === "function";
+}
+function resolvePiiRedactor(piiRedaction) {
+  if (piiRedaction === true) return new PiiRedactor();
+  if (!piiRedaction) return void 0;
+  if (isPiiRedactor(piiRedaction)) return piiRedaction;
+  console.warn(
+    "[PiiRedactor] `piiRedaction` is neither `true` nor a PiiRedactor instance; PII redaction is DISABLED for this request."
+  );
+  return void 0;
+}
+function createStreamingDeAnonymizer(redactor, emit) {
+  let buffer = "";
+  const trailingFragment = /\[[A-Za-z0-9_]*$/;
+  return {
+    push(chunk) {
+      if (!chunk) return;
+      buffer += chunk;
+      const m = buffer.match(trailingFragment);
+      if (!m || m.index === void 0) {
+        emit(redactor.deAnonymize(buffer));
+        buffer = "";
+      } else if (m.index > 0) {
+        emit(redactor.deAnonymize(buffer.slice(0, m.index)));
+        buffer = buffer.slice(m.index);
+      }
+    },
+    flush() {
+      if (buffer) {
+        emit(redactor.deAnonymize(buffer));
+        buffer = "";
+      }
+    }
+  };
+}
+
+export {
+  PiiRedactor,
+  isPiiRedactor,
+  resolvePiiRedactor,
+  createStreamingDeAnonymizer
+};

package/dist/react/clientConfig-VPOGQRNP.mjs

@@ -0,0 +1,12 @@
+import {
+  BASE_URL,
+  MCP_R2_DOMAIN,
+  createClientConfig,
+  resolveBaseUrl
+} from "./chunk-GYKJOWEO.mjs";
+export {
+  BASE_URL,
+  MCP_R2_DOMAIN,
+  createClientConfig,
+  resolveBaseUrl
+};