@framers/agentos-ext-content-policy-rewriter 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Types for the content policy rewriter guardrail.
+ * @module content-policy-rewriter/types
+ */
+/** Policy categories that can be individually enabled/disabled. */
+export type PolicyCategory = 'illegal_harmful' | 'adult' | 'profanity' | 'violence' | 'self_harm' | 'hate_speech' | 'illegal_activity' | 'custom';
+export declare const ALL_POLICY_CATEGORIES: PolicyCategory[];
+/** Per-category configuration. */
+export interface CategoryConfig {
+    enabled?: boolean;
+    action?: 'block' | 'sanitize';
+}
+/** A detected policy violation. */
+export interface PolicyViolation {
+    category: PolicyCategory;
+    severity: 'low' | 'medium' | 'high';
+    spans: string[];
+}
+/** Result from the LLM policy judge. */
+export interface JudgeResult {
+    violations: PolicyViolation[];
+}
+/** LLM invoker callback — matches the pattern used by ml-classifiers. */
+export type LlmInvoker = (systemPrompt: string, userPrompt: string) => Promise<string>;
+/** Full configuration for the content policy rewriter. */
+export interface ContentPolicyRewriterConfig {
+    categories?: Partial<Record<PolicyCategory, CategoryConfig>>;
+    customRules?: string;
+    llm?: {
+        provider?: string;
+        model?: string;
+    };
+    /** Override built-in keyword lists per category. */
+    keywordLists?: Partial<Record<PolicyCategory, string[]>>;
+    /** Enable keyword pre-filter on streaming chunks. Default: true. */
+    streamingPreFilter?: boolean;
+    /** LLM invoker callback. If not provided, uses a default fetch-based invoker. */
+    llmInvoker?: LlmInvoker;
+}
+/** Preset names for shorthand configuration. */
+export type ContentPolicyPreset = 'uncensored' | 'uncensored-safe' | 'family-friendly' | 'enterprise';

package/dist/types.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Types for the content policy rewriter guardrail.
+ * @module content-policy-rewriter/types
+ */
+export const ALL_POLICY_CATEGORIES = [
+    'illegal_harmful', 'adult', 'profanity', 'violence',
+    'self_harm', 'hate_speech', 'illegal_activity', 'custom',
+];

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@framers/agentos-ext-content-policy-rewriter",
+  "version": "0.1.0",
+  "description": "Opt-in content policy guardrail for AgentOS — detects violations and rewrites or blocks output via LLM judge",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@framers/agentos": ">=0.1.0"
+  },
+  "devDependencies": {
+    "@framers/agentos": "workspace:*",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT"
+}

package/src/ContentPolicyRewriterGuardrail.ts

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Main guardrail orchestrator for content policy rewriting.
+ *
+ * Implements IGuardrailService with a two-layer hybrid pipeline:
+ * - Layer 1: KeywordPreFilter on streaming TEXT_DELTA chunks (zero-cost)
+ * - Layer 2: LLM Policy Judge + LLM Rewriter on FINAL_RESPONSE
+ *
+ * Phase 1 sanitizer — sequential execution, can return SANITIZE with modifiedText.
+ *
+ * @module content-policy-rewriter/ContentPolicyRewriterGuardrail
+ */
+
+import type { ContentPolicyRewriterConfig, PolicyCategory, CategoryConfig, LlmInvoker } from './types.js';
+import { resolveCategoryConfig } from './categories.js';
+import { ALL_POLICY_CATEGORIES } from './types.js';
+import { KeywordPreFilter } from './KeywordPreFilter.js';
+import { LlmPolicyJudge } from './LlmPolicyJudge.js';
+import { LlmRewriter } from './LlmRewriter.js';
+
+/** GuardrailAction values (avoid import issues by inlining). */
+const BLOCK = 'block';
+const SANITIZE = 'sanitize';
+
+export interface ContentPolicyRewriterOptions extends ContentPolicyRewriterConfig {
+  llmInvoker: LlmInvoker;
+}
+
+export class ContentPolicyRewriterGuardrail {
+  readonly config = {
+    canSanitize: true,
+    evaluateStreamingChunks: true,
+    streamingMode: 'per-chunk' as const,
+  };
+
+  private enabledCategories: Partial<Record<PolicyCategory, CategoryConfig>>;
+  private keywordFilter: KeywordPreFilter;
+  private judge: LlmPolicyJudge;
+  private rewriter: LlmRewriter;
+  private customRules?: string;
+
+  constructor(options: ContentPolicyRewriterOptions) {
+    this.customRules = options.customRules;
+
+    // Resolve enabled categories
+    this.enabledCategories = {};
+    for (const cat of ALL_POLICY_CATEGORIES) {
+      const resolved = resolveCategoryConfig(cat, options.categories);
+      if (resolved.enabled) {
+        this.enabledCategories[cat] = { enabled: true, action: resolved.action };
+      }
+    }
+
+    this.keywordFilter = new KeywordPreFilter(options.keywordLists);
+    this.judge = new LlmPolicyJudge(options.llmInvoker);
+    this.rewriter = new LlmRewriter(options.llmInvoker);
+
+    if (options.streamingPreFilter === false) {
+      this.config.evaluateStreamingChunks = false;
+    }
+  }
+
+  async evaluateInput(_payload: any): Promise<any> {
+    return null; // Content policy rewriter only evaluates output
+  }
+
+  async evaluateOutput(payload: any): Promise<any> {
+    const chunk = payload?.chunk;
+    if (!chunk) return null;
+
+    const hasEnabledCategories = Object.keys(this.enabledCategories).length > 0;
+    if (!hasEnabledCategories) return null;
+
+    // Layer 1: Keyword pre-filter on streaming chunks
+    if (chunk.type === 'TEXT_DELTA' && chunk.text) {
+      const match = this.keywordFilter.scan(chunk.text, this.enabledCategories);
+      if (match) {
+        const action = this.enabledCategories[match.category]?.action ?? BLOCK;
+        return {
+          action,
+          reasonCode: `KEYWORD_${match.category.toUpperCase()}`,
+          ...(action === SANITIZE ? { modifiedText: '[Content removed by policy]' } : {}),
+        };
+      }
+      return null;
+    }
+
+    // Layer 2: LLM judge + rewriter on final response
+    if (chunk.type === 'FINAL_RESPONSE' && chunk.finalResponseText) {
+      const text = chunk.finalResponseText;
+
+      // Quick keyword check — BLOCK immediately if keyword match + action=block
+      const kwMatch = this.keywordFilter.scan(text, this.enabledCategories);
+      if (kwMatch && this.enabledCategories[kwMatch.category]?.action === BLOCK) {
+        return {
+          action: BLOCK,
+          reasonCode: `KEYWORD_${kwMatch.category.toUpperCase()}`,
+        };
+      }
+
+      // LLM classification
+      const judgeResult = await this.judge.classify(text, this.enabledCategories, this.customRules);
+      if (judgeResult.violations.length === 0) return null;
+
+      // Check if all violations map to BLOCK
+      const allBlock = judgeResult.violations.every(
+        v => this.enabledCategories[v.category]?.action === BLOCK,
+      );
+      if (allBlock) {
+        return {
+          action: BLOCK,
+          reasonCode: judgeResult.violations.map(v => v.category).join(','),
+        };
+      }
+
+      // At least one SANITIZE — rewrite
+      const rewritten = await this.rewriter.rewrite(text, judgeResult.violations, this.customRules);
+      return {
+        action: SANITIZE,
+        modifiedText: rewritten,
+        reasonCode: judgeResult.violations.map(v => v.category).join(','),
+      };
+    }
+
+    return null;
+  }
+}

package/src/KeywordPreFilter.ts

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Layer 1: Zero-cost keyword/regex pre-filter for streaming chunks.
+ * Scans text against per-category keyword lists. No LLM calls.
+ * @module content-policy-rewriter/KeywordPreFilter
+ */
+
+import type { PolicyCategory, CategoryConfig } from './types.js';
+import { DEFAULT_KEYWORD_LISTS } from './categories.js';
+
+export interface KeywordMatch {
+  category: PolicyCategory;
+  keyword: string;
+}
+
+export class KeywordPreFilter {
+  private patterns: Map<PolicyCategory, RegExp[]>;
+
+  constructor(customLists?: Partial<Record<PolicyCategory, string[]>>) {
+    this.patterns = new Map();
+    const merged = { ...DEFAULT_KEYWORD_LISTS, ...customLists };
+    for (const [cat, keywords] of Object.entries(merged)) {
+      if (keywords?.length) {
+        this.patterns.set(
+          cat as PolicyCategory,
+          keywords.map(kw => new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i')),
+        );
+      }
+    }
+  }
+
+  /**
+   * Scan text against enabled category keyword lists.
+   * @returns First match found, or null if clean.
+   */
+  scan(
+    text: string,
+    enabledCategories: Partial<Record<PolicyCategory, CategoryConfig>>,
+  ): KeywordMatch | null {
+    for (const [cat, patterns] of this.patterns) {
+      const cfg = enabledCategories[cat];
+      if (!cfg?.enabled) continue;
+      for (const re of patterns) {
+        const match = text.match(re);
+        if (match) return { category: cat, keyword: match[0] };
+      }
+    }
+    return null;
+  }
+}

package/src/LlmPolicyJudge.ts

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Layer 2a: LLM-based policy violation classifier.
+ * Sends the full response text to an LLM with a structured classification prompt.
+ * @module content-policy-rewriter/LlmPolicyJudge
+ */
+
+import type { LlmInvoker, PolicyCategory, CategoryConfig, JudgeResult } from './types.js';
+import { CATEGORY_DESCRIPTIONS } from './categories.js';
+
+const SYSTEM_PROMPT = `You are a content policy classifier. Analyze the provided text and identify any violations of the enabled policy categories. Respond with JSON only. If no violations, respond: { "violations": [] }`;
+
+export class LlmPolicyJudge {
+  constructor(private llmInvoker: LlmInvoker) {}
+
+  async classify(
+    text: string,
+    enabledCategories: Partial<Record<PolicyCategory, CategoryConfig>>,
+    customRules?: string,
+  ): Promise<JudgeResult> {
+    const categoryList = Object.entries(enabledCategories)
+      .filter(([, cfg]) => cfg?.enabled)
+      .map(([cat]) => `- ${cat}: ${CATEGORY_DESCRIPTIONS[cat as PolicyCategory]}`)
+      .join('\n');
+
+    if (!categoryList) return { violations: [] };
+
+    let userPrompt = `Enabled categories:\n${categoryList}\n`;
+    if (customRules) userPrompt += `\nCustom rules: ${customRules}\n`;
+    userPrompt += `\nText to analyze:\n"""\n${text}\n"""\n\nRespond with JSON: { "violations": [{ "category": "...", "severity": "low|medium|high", "spans": ["offending phrase"] }] }`;
+
+    try {
+      const raw = await this.llmInvoker(SYSTEM_PROMPT, userPrompt);
+      const cleaned = raw.replace(/```json\n?|```\n?/g, '').trim();
+      const parsed = JSON.parse(cleaned) as JudgeResult;
+      if (!Array.isArray(parsed.violations)) return { violations: [] };
+      return parsed;
+    } catch {
+      return { violations: [] };
+    }
+  }
+}

package/src/LlmRewriter.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Layer 2b: LLM-based content rewriter.
+ * Takes text with identified violations and rewrites it to remove them.
+ * @module content-policy-rewriter/LlmRewriter
+ */
+
+import type { LlmInvoker, PolicyViolation } from './types.js';
+
+const SYSTEM_PROMPT = `Rewrite the following text to remove policy violations while preserving the original meaning, tone, and information content. Do not add disclaimers or commentary — just output the clean version.`;
+
+export class LlmRewriter {
+  constructor(private llmInvoker: LlmInvoker) {}
+
+  async rewrite(text: string, violations: PolicyViolation[], customRules?: string): Promise<string> {
+    if (violations.length === 0) return text;
+
+    const violationList = violations
+      .map(v => `- ${v.category}: ${v.spans.map(s => `"${s}"`).join(', ')}`)
+      .join('\n');
+
+    let userPrompt = `Violations to remove:\n${violationList}\n`;
+    if (customRules) userPrompt += `\nAdditional rules: ${customRules}\n`;
+    userPrompt += `\nOriginal text:\n"""\n${text}\n"""\n\nRewritten text:`;
+
+    try {
+      const raw = await this.llmInvoker(SYSTEM_PROMPT, userPrompt);
+      return raw.replace(/^```\w*\s*\n?/gm, '').replace(/\n?```\s*$/gm, '').trim() || text;
+    } catch {
+      return text;
+    }
+  }
+}

package/src/categories.ts

@@ -0,0 +1,77 @@
+/**
+ * @fileoverview Built-in keyword lists per policy category.
+ * @module content-policy-rewriter/categories
+ */
+
+import type { PolicyCategory, CategoryConfig } from './types.js';
+
+/** Default category descriptions used in LLM judge prompts. */
+export const CATEGORY_DESCRIPTIONS: Record<PolicyCategory, string> = {
+  illegal_harmful: 'Child sexual abuse material (CSAM), sexual assault, bestiality, non-consensual acts, exploitation of minors, graphic torture',
+  adult: 'Consensual sexually explicit content, pornographic descriptions',
+  profanity: 'Slurs, vulgar language, obscenity, crude insults',
+  violence: 'Graphic violence, gore, detailed injury descriptions',
+  self_harm: 'Self-harm instructions, suicide methods, pro-anorexia content',
+  hate_speech: 'Discriminatory language, bigotry, slurs targeting protected groups',
+  illegal_activity: 'Drug synthesis instructions, weapons manufacturing, hacking tutorials',
+  custom: 'User-defined policy rules',
+};
+
+/** Default actions per category. */
+export const DEFAULT_CATEGORY_ACTIONS: Record<PolicyCategory, 'block' | 'sanitize'> = {
+  illegal_harmful: 'block',
+  adult: 'sanitize',
+  profanity: 'sanitize',
+  violence: 'sanitize',
+  self_harm: 'block',
+  hate_speech: 'sanitize',
+  illegal_activity: 'block',
+  custom: 'sanitize',
+};
+
+/** Default enabled state — only illegal_harmful is on by default. */
+export const DEFAULT_CATEGORY_ENABLED: Record<PolicyCategory, boolean> = {
+  illegal_harmful: true,
+  adult: false,
+  profanity: false,
+  violence: false,
+  self_harm: false,
+  hate_speech: false,
+  illegal_activity: false,
+  custom: false,
+};
+
+/**
+ * Built-in keyword lists for the streaming pre-filter.
+ * Intentionally broad — false positives acceptable because the LLM judge
+ * runs on the final response for accuracy.
+ */
+export const DEFAULT_KEYWORD_LISTS: Partial<Record<PolicyCategory, string[]>> = {
+  profanity: [
+    'fuck', 'shit', 'bitch', 'asshole', 'cunt', 'dick', 'bastard',
+    'damn', 'nigger', 'faggot', 'retard', 'slut', 'whore',
+  ],
+  illegal_harmful: [
+    'child porn', 'cp links', 'lolicon', 'underage sex', 'rape fantasy',
+    'snuff film', 'crush video',
+  ],
+  self_harm: [
+    'how to kill yourself', 'suicide method', 'cut yourself', 'end it all',
+  ],
+  hate_speech: [
+    'kill all', 'gas the', 'ethnic cleansing', 'race war', 'white power',
+    'heil hitler', 'death to',
+  ],
+};
+
+/** Resolve effective config for a category. */
+export function resolveCategoryConfig(
+  category: PolicyCategory,
+  userConfig?: Partial<Record<PolicyCategory, CategoryConfig>>,
+): { enabled: boolean; action: 'block' | 'sanitize' } {
+  const cfg = userConfig?.[category];
+  return {
+    enabled: cfg?.enabled ?? DEFAULT_CATEGORY_ENABLED[category],
+    action: cfg?.action ?? DEFAULT_CATEGORY_ACTIONS[category],
+  };
+}

package/src/index.ts

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Content Policy Rewriter — extension pack factory.
+ *
+ * Opt-in guardrail that detects content policy violations in agent output
+ * and either blocks or rewrites them via LLM. Agents are uncensored by
+ * default — this extension only activates when explicitly configured.
+ *
+ * @module content-policy-rewriter
+ */
+
+import type { ContentPolicyRewriterConfig, LlmInvoker } from './types.js';
+import { ContentPolicyRewriterGuardrail } from './ContentPolicyRewriterGuardrail.js';
+import { resolvePreset } from './presets.js';
+
+export * from './types.js';
+export { ContentPolicyRewriterGuardrail } from './ContentPolicyRewriterGuardrail.js';
+export { KeywordPreFilter } from './KeywordPreFilter.js';
+export { LlmPolicyJudge } from './LlmPolicyJudge.js';
+export { LlmRewriter } from './LlmRewriter.js';
+export { resolvePreset } from './presets.js';
+
+/**
+ * Create the content policy rewriter extension pack.
+ *
+ * @param config - Policy configuration or preset name.
+ * @param llmInvoker - Callback to invoke an LLM for classification and rewriting.
+ * @returns A configured ExtensionPack.
+ */
+export function createContentPolicyRewriter(
+  config: ContentPolicyRewriterConfig | string = {},
+  llmInvoker?: LlmInvoker,
+) {
+  const resolved = typeof config === 'string' ? resolvePreset(config as any) : config;
+
+  const invoker: LlmInvoker = llmInvoker ?? resolved.llmInvoker ?? createDefaultInvoker(resolved);
+  const guardrail = new ContentPolicyRewriterGuardrail({ ...resolved, llmInvoker: invoker });
+
+  return {
+    name: 'content-policy-rewriter',
+    version: '0.1.0',
+    descriptors: [
+      {
+        id: 'content-policy-rewriter-guardrail',
+        kind: 'guardrail' as const,
+        priority: 3,
+        payload: guardrail,
+      },
+    ],
+  };
+}
+
+/** Manifest factory bridge for extension loader. */
+export function createExtensionPack(context: any) {
+  return createContentPolicyRewriter(
+    context.options as ContentPolicyRewriterConfig,
+    context.llmInvoker,
+  );
+}
+
+/** Default LLM invoker using fetch to OpenAI-compatible API. */
+function createDefaultInvoker(config: ContentPolicyRewriterConfig): LlmInvoker {
+  return async (systemPrompt: string, userPrompt: string): Promise<string> => {
+    const apiKey = process.env.OPENAI_API_KEY || process.env.OPENROUTER_API_KEY;
+    if (!apiKey) throw new Error('No LLM API key for content policy judge');
+
+    const isOpenRouter = !process.env.OPENAI_API_KEY && !!process.env.OPENROUTER_API_KEY;
+    const baseUrl = isOpenRouter ? 'https://openrouter.ai/api/v1' : 'https://api.openai.com/v1';
+    const model = config.llm?.model ?? (isOpenRouter ? 'anthropic/claude-haiku-4-5-20251001' : 'gpt-4o-mini');
+
+    const res = await fetch(`${baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+        ...(isOpenRouter && { 'HTTP-Referer': 'https://agentos.sh' }),
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: userPrompt },
+        ],
+        max_tokens: 2048,
+        temperature: 0.1,
+      }),
+    });
+
+    if (!res.ok) throw new Error(`LLM API returned ${res.status}`);
+    const data = (await res.json()) as any;
+    return data.choices?.[0]?.message?.content ?? '';
+  };
+}

package/src/presets.ts

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview Preset configurations for common content policy scenarios.
+ * @module content-policy-rewriter/presets
+ */
+
+import type { ContentPolicyRewriterConfig, ContentPolicyPreset, PolicyCategory, CategoryConfig } from './types.js';
+
+const ALL_ENABLED_SANITIZE: Partial<Record<PolicyCategory, CategoryConfig>> = {
+  illegal_harmful: { enabled: true, action: 'block' },
+  adult: { enabled: true, action: 'sanitize' },
+  profanity: { enabled: true, action: 'sanitize' },
+  violence: { enabled: true, action: 'sanitize' },
+  self_harm: { enabled: true, action: 'block' },
+  hate_speech: { enabled: true, action: 'sanitize' },
+  illegal_activity: { enabled: true, action: 'block' },
+};
+
+const PRESET_CONFIGS: Record<ContentPolicyPreset, Partial<ContentPolicyRewriterConfig>> = {
+  uncensored: {
+    categories: {
+      illegal_harmful: { enabled: false },
+      adult: { enabled: false },
+      profanity: { enabled: false },
+      violence: { enabled: false },
+      self_harm: { enabled: false },
+      hate_speech: { enabled: false },
+      illegal_activity: { enabled: false },
+    },
+  },
+  'uncensored-safe': {
+    categories: {
+      illegal_harmful: { enabled: true, action: 'block' },
+    },
+  },
+  'family-friendly': {
+    categories: ALL_ENABLED_SANITIZE,
+  },
+  enterprise: {
+    categories: ALL_ENABLED_SANITIZE,
+  },
+};
+
+/** Resolve a preset string or config object into a full config. */
+export function resolvePreset(
+  input: ContentPolicyPreset | ContentPolicyRewriterConfig,
+): ContentPolicyRewriterConfig {
+  if (typeof input === 'string') {
+    const preset = PRESET_CONFIGS[input];
+    if (!preset) return {};
+    return { ...preset };
+  }
+  return input;
+}

package/src/types.ts

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Types for the content policy rewriter guardrail.
+ * @module content-policy-rewriter/types
+ */
+
+/** Policy categories that can be individually enabled/disabled. */
+export type PolicyCategory =
+  | 'illegal_harmful'
+  | 'adult'
+  | 'profanity'
+  | 'violence'
+  | 'self_harm'
+  | 'hate_speech'
+  | 'illegal_activity'
+  | 'custom';
+
+export const ALL_POLICY_CATEGORIES: PolicyCategory[] = [
+  'illegal_harmful', 'adult', 'profanity', 'violence',
+  'self_harm', 'hate_speech', 'illegal_activity', 'custom',
+];
+
+/** Per-category configuration. */
+export interface CategoryConfig {
+  enabled?: boolean;
+  action?: 'block' | 'sanitize';
+}
+
+/** A detected policy violation. */
+export interface PolicyViolation {
+  category: PolicyCategory;
+  severity: 'low' | 'medium' | 'high';
+  spans: string[];
+}
+
+/** Result from the LLM policy judge. */
+export interface JudgeResult {
+  violations: PolicyViolation[];
+}
+
+/** LLM invoker callback — matches the pattern used by ml-classifiers. */
+export type LlmInvoker = (systemPrompt: string, userPrompt: string) => Promise<string>;
+
+/** Full configuration for the content policy rewriter. */
+export interface ContentPolicyRewriterConfig {
+  categories?: Partial<Record<PolicyCategory, CategoryConfig>>;
+  customRules?: string;
+  llm?: {
+    provider?: string;
+    model?: string;
+  };
+  /** Override built-in keyword lists per category. */
+  keywordLists?: Partial<Record<PolicyCategory, string[]>>;
+  /** Enable keyword pre-filter on streaming chunks. Default: true. */
+  streamingPreFilter?: boolean;
+  /** LLM invoker callback. If not provided, uses a default fetch-based invoker. */
+  llmInvoker?: LlmInvoker;
+}
+
+/** Preset names for shorthand configuration. */
+export type ContentPolicyPreset = 'uncensored' | 'uncensored-safe' | 'family-friendly' | 'enterprise';