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

package/README.md

@@ -0,0 +1,91 @@
+# @framers/agentos-ext-content-policy-rewriter
+
+Opt-in content policy guardrail for AgentOS — detects violations in agent output and either blocks or rewrites them to compliant versions via LLM judge.
+
+**Agents are uncensored by default.** This extension only activates when explicitly configured.
+
+## Features
+
+- **Two-layer hybrid pipeline:** keyword pre-filter on streaming chunks (zero-cost) + LLM judge/rewriter on final response
+- **8 configurable categories:** illegal_harmful, adult, profanity, violence, self_harm, hate_speech, illegal_activity, custom
+- **4 presets:** uncensored, uncensored-safe, family-friendly, enterprise
+- **Fully configurable:** every category can be enabled/disabled, action set to block or sanitize
+- **No hardcoded restrictions:** all policies are user-controlled
+
+## Quick Start
+
+```typescript
+import { createContentPolicyRewriter } from '@framers/agentos-ext-content-policy-rewriter';
+
+// Minimal — blocks illegal_harmful content only (default)
+const pack = createContentPolicyRewriter({});
+
+// Family-friendly preset
+const pack = createContentPolicyRewriter('family-friendly');
+
+// Custom configuration
+const pack = createContentPolicyRewriter({
+  categories: {
+    adult: { enabled: true, action: 'sanitize' },
+    profanity: { enabled: true, action: 'sanitize' },
+    violence: { enabled: true, action: 'block' },
+  },
+  customRules: 'Never mention competitor products by name.',
+});
+
+// Truly uncensored — zero filtering
+const pack = createContentPolicyRewriter('uncensored');
+```
+
+## agent.config.json
+
+```json
+{
+  "guardrails": {
+    "contentPolicy": {
+      "enabled": true,
+      "categories": {
+        "illegal_harmful": { "enabled": true, "action": "block" },
+        "adult": { "enabled": true, "action": "sanitize" },
+        "profanity": { "enabled": true, "action": "sanitize" }
+      }
+    }
+  }
+}
+```
+
+Or shorthand:
+
+```json
+{
+  "guardrails": {
+    "contentPolicy": "uncensored-safe"
+  }
+}
+```
+
+## Categories
+
+| Category | Description | Default |
+|---|---|---|
+| `illegal_harmful` | CSAM, sexual assault, bestiality, exploitation | enabled, block |
+| `adult` | Consensual sexually explicit content | disabled |
+| `profanity` | Slurs, vulgar language | disabled |
+| `violence` | Graphic violence, gore | disabled |
+| `self_harm` | Self-harm, suicide instructions | disabled |
+| `hate_speech` | Discriminatory, bigoted content | disabled |
+| `illegal_activity` | Drug synthesis, weapons manufacturing | disabled |
+| `custom` | User-defined policy rules | disabled |
+
+## Presets
+
+| Preset | Effect |
+|---|---|
+| `uncensored` | All categories disabled — zero filtering |
+| `uncensored-safe` | Only `illegal_harmful` enabled |
+| `family-friendly` | All categories enabled (sanitize where possible) |
+| `enterprise` | All categories enabled + custom rules |
+
+## License
+
+MIT

package/dist/ContentPolicyRewriterGuardrail.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @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, LlmInvoker } from './types.js';
+export interface ContentPolicyRewriterOptions extends ContentPolicyRewriterConfig {
+    llmInvoker: LlmInvoker;
+}
+export declare class ContentPolicyRewriterGuardrail {
+    readonly config: {
+        canSanitize: boolean;
+        evaluateStreamingChunks: boolean;
+        streamingMode: "per-chunk";
+    };
+    private enabledCategories;
+    private keywordFilter;
+    private judge;
+    private rewriter;
+    private customRules?;
+    constructor(options: ContentPolicyRewriterOptions);
+    evaluateInput(_payload: any): Promise<any>;
+    evaluateOutput(payload: any): Promise<any>;
+}

package/dist/ContentPolicyRewriterGuardrail.js

@@ -0,0 +1,104 @@
+/**
+ * @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 { 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 class ContentPolicyRewriterGuardrail {
+    config = {
+        canSanitize: true,
+        evaluateStreamingChunks: true,
+        streamingMode: 'per-chunk',
+    };
+    enabledCategories;
+    keywordFilter;
+    judge;
+    rewriter;
+    customRules;
+    constructor(options) {
+        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) {
+        return null; // Content policy rewriter only evaluates output
+    }
+    async evaluateOutput(payload) {
+        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/dist/KeywordPreFilter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @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';
+export interface KeywordMatch {
+    category: PolicyCategory;
+    keyword: string;
+}
+export declare class KeywordPreFilter {
+    private patterns;
+    constructor(customLists?: Partial<Record<PolicyCategory, string[]>>);
+    /**
+     * 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;
+}

package/dist/KeywordPreFilter.js

@@ -0,0 +1,35 @@
+/**
+ * @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 { DEFAULT_KEYWORD_LISTS } from './categories.js';
+export class KeywordPreFilter {
+    patterns;
+    constructor(customLists) {
+        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, 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, enabledCategories) {
+        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/dist/LlmPolicyJudge.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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';
+export declare class LlmPolicyJudge {
+    private llmInvoker;
+    constructor(llmInvoker: LlmInvoker);
+    classify(text: string, enabledCategories: Partial<Record<PolicyCategory, CategoryConfig>>, customRules?: string): Promise<JudgeResult>;
+}

package/dist/LlmPolicyJudge.js

@@ -0,0 +1,36 @@
+/**
+ * @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 { 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 {
+    llmInvoker;
+    constructor(llmInvoker) {
+        this.llmInvoker = llmInvoker;
+    }
+    async classify(text, enabledCategories, customRules) {
+        const categoryList = Object.entries(enabledCategories)
+            .filter(([, cfg]) => cfg?.enabled)
+            .map(([cat]) => `- ${cat}: ${CATEGORY_DESCRIPTIONS[cat]}`)
+            .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);
+            if (!Array.isArray(parsed.violations))
+                return { violations: [] };
+            return parsed;
+        }
+        catch {
+            return { violations: [] };
+        }
+    }
+}

package/dist/LlmRewriter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @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';
+export declare class LlmRewriter {
+    private llmInvoker;
+    constructor(llmInvoker: LlmInvoker);
+    rewrite(text: string, violations: PolicyViolation[], customRules?: string): Promise<string>;
+}

package/dist/LlmRewriter.js

@@ -0,0 +1,30 @@
+/**
+ * @fileoverview Layer 2b: LLM-based content rewriter.
+ * Takes text with identified violations and rewrites it to remove them.
+ * @module content-policy-rewriter/LlmRewriter
+ */
+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 {
+    llmInvoker;
+    constructor(llmInvoker) {
+        this.llmInvoker = llmInvoker;
+    }
+    async rewrite(text, violations, customRules) {
+        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/dist/categories.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @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 declare const CATEGORY_DESCRIPTIONS: Record<PolicyCategory, string>;
+/** Default actions per category. */
+export declare const DEFAULT_CATEGORY_ACTIONS: Record<PolicyCategory, 'block' | 'sanitize'>;
+/** Default enabled state — only illegal_harmful is on by default. */
+export declare const DEFAULT_CATEGORY_ENABLED: Record<PolicyCategory, boolean>;
+/**
+ * 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 declare const DEFAULT_KEYWORD_LISTS: Partial<Record<PolicyCategory, string[]>>;
+/** Resolve effective config for a category. */
+export declare function resolveCategoryConfig(category: PolicyCategory, userConfig?: Partial<Record<PolicyCategory, CategoryConfig>>): {
+    enabled: boolean;
+    action: 'block' | 'sanitize';
+};

package/dist/categories.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview Built-in keyword lists per policy category.
+ * @module content-policy-rewriter/categories
+ */
+/** Default category descriptions used in LLM judge prompts. */
+export const CATEGORY_DESCRIPTIONS = {
+    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 = {
+    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 = {
+    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 = {
+    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, userConfig) {
+    const cfg = userConfig?.[category];
+    return {
+        enabled: cfg?.enabled ?? DEFAULT_CATEGORY_ENABLED[category],
+        action: cfg?.action ?? DEFAULT_CATEGORY_ACTIONS[category],
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @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';
+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 declare function createContentPolicyRewriter(config?: ContentPolicyRewriterConfig | string, llmInvoker?: LlmInvoker): {
+    name: string;
+    version: string;
+    descriptors: {
+        id: string;
+        kind: "guardrail";
+        priority: number;
+        payload: ContentPolicyRewriterGuardrail;
+    }[];
+};
+/** Manifest factory bridge for extension loader. */
+export declare function createExtensionPack(context: any): {
+    name: string;
+    version: string;
+    descriptors: {
+        id: string;
+        kind: "guardrail";
+        priority: number;
+        payload: ContentPolicyRewriterGuardrail;
+    }[];
+};

package/dist/index.js

@@ -0,0 +1,77 @@
+/**
+ * @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 { 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 = {}, llmInvoker) {
+    const resolved = typeof config === 'string' ? resolvePreset(config) : config;
+    const invoker = 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',
+                priority: 3,
+                payload: guardrail,
+            },
+        ],
+    };
+}
+/** Manifest factory bridge for extension loader. */
+export function createExtensionPack(context) {
+    return createContentPolicyRewriter(context.options, context.llmInvoker);
+}
+/** Default LLM invoker using fetch to OpenAI-compatible API. */
+function createDefaultInvoker(config) {
+    return async (systemPrompt, userPrompt) => {
+        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());
+        return data.choices?.[0]?.message?.content ?? '';
+    };
+}

package/dist/presets.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @fileoverview Preset configurations for common content policy scenarios.
+ * @module content-policy-rewriter/presets
+ */
+import type { ContentPolicyRewriterConfig, ContentPolicyPreset } from './types.js';
+/** Resolve a preset string or config object into a full config. */
+export declare function resolvePreset(input: ContentPolicyPreset | ContentPolicyRewriterConfig): ContentPolicyRewriterConfig;

package/dist/presets.js

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Preset configurations for common content policy scenarios.
+ * @module content-policy-rewriter/presets
+ */
+const ALL_ENABLED_SANITIZE = {
+    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 = {
+    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) {
+    if (typeof input === 'string') {
+        const preset = PRESET_CONFIGS[input];
+        if (!preset)
+            return {};
+        return { ...preset };
+    }
+    return input;
+}