import { Moderator } from 'council-mod';

const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,  // Optional, falls back to local
});

const result = await moderator.moderate("Your text here");

console.log(result.action);            // 'allow' | 'deny' | 'escalate'
console.log(result.flagged);           // true (if action === 'deny')
console.log(result.severity);          // 0.0 - 1.0
console.log(result.confidence);        // 0.0 - 1.0
console.log(result.tierInfo.tier);     // 'local' | 'api' | 'council' | 'human'

import { Moderator } from 'council-mod';

const mod = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
});

// Simple check
const result = await mod.moderate("This is fine");
console.log(result.action);  // 'allow'

// Handles obfuscation
const result2 = await mod.moderate("f4gg0t");
console.log(result2.flagged);  // true
console.log(result2.normalized);  // 'faggot'

// Understands context
const result3 = await mod.moderate(
  "The word 'faggot' has been historically used as a slur"
);
console.log(result3.action);  // 'allow' (educational context)

// Ambiguous short text
const result = await mod.moderate("にがー");  // Could be "bitter" or slur
console.log(result.action);  // 'escalate' (needs context)

// With conversation context
const result2 = await mod.moderate("にがー", {
  context: ["コーヒー飲んだ", "めっちゃ濃かった"]
});
console.log(result2.action);  // 'allow' (clearly means "bitter coffee")

// Skip API, local-only (~3ms)
const quick = await mod.quickCheck("hello world");
console.log(quick.flagged);  // false
console.log(quick.latencyMs);  // ~3

const mod = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
  council: {
    enabled: true,
    members: ['anthropic', 'gemini'],
  },
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  googleApiKey: process.env.GOOGLE_API_KEY,
});

// Ambiguous case triggers council
const result = await mod.moderate("borderline content");
console.log(result.tierInfo.tier);  // 'council'
console.log(result.action);  // Multiple models voted

// High accuracy (expensive)
council: {
  members: ['anthropic', 'gemini'],  // Best agreement with human
}

// Balanced (recommended)
council: {
  members: ['anthropic', 'openai'],  // Good accuracy, no quota issues
}

// Budget (cheaper)
council: {
  members: ['gemini', 'openai-mini'],  // Lower cost, still decent
}

// High volume (fast)
council: {
  members: ['openai-mini', 'gemini'],  // Faster responses
}

const moderator = new Moderator({
  // Provider selection
  provider: 'openai',  // 'openai' | 'perspective' | 'local-only'
  openaiApiKey: process.env.OPENAI_API_KEY,
  
  // Fast-path optimization
  fastPath: {
    enabled: true,
    localBlockThreshold: 0.85,    // Skip API, instant block
    localAllowThreshold: 0.10,    // Skip API, instant allow
    minLocalConfidence: 0.70,     // Required confidence for fast-path
    alwaysCheckCategories: ['self_harm', 'child_safety', 'threats'],
  },
  
  // Council configuration
  council: {
    enabled: true,
    members: ['anthropic', 'gemini'],  // Council voters
    escalateMin: 0.30,                  // Escalate if confidence >= 30%
    escalateMax: 0.70,                  // Escalate if confidence <= 70%
    sendSplitsToHuman: true,            // Split votes → human queue
    sendLowConfidenceToHuman: true,     // Low confidence majority → human queue
  },
  
  // Thresholds
  allowThreshold: 0.3,        // Severity < 30% = ALLOW
  denyThreshold: 0.7,         // Severity >= 70% = DENY
  confidenceThreshold: 0.7,   // Confidence < 70% = ESCALATE
  
  // Behavior
  normalizeText: true,      // Apply obfuscation detection
  analyzeContext: true,     // Evaluate intent/reclamation
});

// Caching is enabled by default
const moderator = new Moderator({
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  googleApiKey: process.env.GOOGLE_API_KEY,
});

// Disable caching if needed (not recommended)
const provider = new AnthropicProvider({
  apiKey: process.env.ANTHROPIC_API_KEY,
  enableCaching: false,  // Default: true
});

// Get provider cache stats (for cost tracking)
const anthropicProvider = new AnthropicProvider({ apiKey: '...' });
// ... after some requests ...
console.log(anthropicProvider.getCacheStats());
// {
//   totalRequests: 100,
//   cacheHits: 99,
//   cacheCreations: 1,
//   inputTokens: 10000,
//   cachedTokens: 84150,
//   savingsPercent: '89.4'
// }

interface ExtendedModerationResult {
  action: FinalAction;                 // 'allow' | 'deny' | 'escalate'
  flagged: boolean;                    // true if action === 'deny'
  severity: number;                    // 0.0 - 1.0
  confidence: number;                  // Model confidence
  categories: CategoryScores;          // Per-category scores
  contextFactors: ContextFactors;      // Intent, target, reclamation, etc.
  flaggedSpans: FlaggedSpan[];         // Specific flagged terms
  normalized: string;                  // Text after normalization
  original: string;                    // Original input
  processingTimeMs: number;            // Latency
  tierInfo: TierInfo;                  // Which tier handled this
}

interface TierInfo {
  tier: 'local' | 'api' | 'council' | 'human';
  reason: string;
  localLatencyMs: number;
  apiLatencyMs?: number;
  councilLatencyMs?: number;
  skippedApi: boolean;
  skippedCouncil: boolean;
}

import { Filter } from 'council-mod';

const filter = new Filter();
filter.isProfane("some text");  // boolean
filter.clean("some text");      // censored string

import { Moderator } from 'council-mod';

const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
  // Fallback to local if API unavailable
  provider: 'openai',
});

async function moderateContent(text: string) {
  try {
    const result = await moderator.moderate(text);
    return result;
  } catch (error) {
    console.error('Moderation error:', error);
    
    // Fallback: Use local-only check
    try {
      const localResult = await moderator.quickCheck(text);
      return {
        action: localResult.flagged ? 'deny' : 'allow',
        flagged: localResult.flagged,
        severity: localResult.severity,
        confidence: 0.5,  // Lower confidence for fallback
        tierInfo: { tier: 'local', reason: 'API unavailable' },
      };
    } catch (fallbackError) {
      // Ultimate fallback: allow but log for review
      console.error('Local fallback failed:', fallbackError);
      return {
        action: 'escalate',
        flagged: false,
        severity: 0,
        confidence: 0,
        tierInfo: { tier: 'human', reason: 'system error' },
      };
    }
  }
}

class RateLimitedModerator {
  private moderator: Moderator;
  private queue: Array<{ text: string; resolve: Function }> = [];
  private processing = false;
  private requestsPerMinute = 50;  // Adjust based on your tier
  
  constructor(config) {
    this.moderator = new Moderator(config);
  }
  
  async moderate(text: string): Promise<ExtendedModerationResult> {
    return new Promise((resolve) => {
      this.queue.push({ text, resolve });
      this.processQueue();
    });
  }
  
  private async processQueue() {
    if (this.processing || this.queue.length === 0) return;
    
    this.processing = true;
    const delay = 60000 / this.requestsPerMinute; // ms between requests
    
    while (this.queue.length > 0) {
      const item = this.queue.shift()!;
      const result = await this.moderator.moderate(item.text);
      item.resolve(result);
      
      if (this.queue.length > 0) {
        await new Promise(r => setTimeout(r, delay));
      }
    }
    
    this.processing = false;
  }
}

import { Moderator } from 'council-mod';
import express from 'express';

const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
  denyThreshold: 0.7,
});

// Middleware to moderate request content
const moderateContent = (field: string) => {
  return async (req, res, next) => {
    const text = req.body[field];
    
    if (!text) return next();
    
    try {
      const result = await moderator.moderate(text, {
        userId: req.user?.id,
        platform: 'web',
      });
      
      if (result.action === 'deny') {
        return res.status(400).json({
          error: 'Content violates community guidelines',
          details: {
            severity: result.severity,
            categories: Object.keys(result.categories)
              .filter(k => result.categories[k] > 0.5),
          },
        });
      }
      
      if (result.action === 'escalate') {
        // Log for human review but allow through
        console.log('Escalated for review:', {
          userId: req.user?.id,
          text: result.flaggedSpans,
        });
      }
      
      // Attach moderation result to request
      req.moderationResult = result;
      next();
    } catch (error) {
      console.error('Moderation error:', error);
      // Fail open or closed based on your needs
      next();  // Fail open: allow on error
      // res.status(503).json({ error: 'Moderation unavailable' });  // Fail closed
    }
  };
};

app.post('/api/comments', moderateContent('text'), (req, res) => {
  // Comment is pre-moderated
  // Save to database...
  res.json({ success: true });
});

import { Client, Message } from 'discord.js';
import { Moderator } from 'council-mod';

const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
});

const client = new Client({ intents: ['GUILDS', 'GUILD_MESSAGES'] });

client.on('messageCreate', async (message: Message) => {
  if (message.author.bot) return;
  
  const result = await moderator.moderate(message.content, {
    userId: message.author.id,
    platform: 'discord',
  });
  
  if (result.action === 'deny') {
    await message.delete();
    await message.author.send(
      `Your message was removed for violating guidelines (severity: ${(result.severity * 100).toFixed(0)}%)`
    );
    
    // Log to mod channel
    const modChannel = message.guild?.channels.cache.find(
      c => c.name === 'mod-log'
    );
    await modChannel?.send({
      embeds: [{
        title: 'Message Removed',
        fields: [
          { name: 'User', value: message.author.tag },
          { name: 'Channel', value: message.channel.toString() },
          { name: 'Content', value: message.content },
          { name: 'Severity', value: `${(result.severity * 100).toFixed(0)}%` },
          { name: 'Categories', value: Object.keys(result.categories).join(', ') },
        ],
      }],
    });
  }
});

async function moderateBatch(texts: string[]): Promise<ExtendedModerationResult[]> {
  const moderator = new Moderator({
    openaiApiKey: process.env.OPENAI_API_KEY,
  });
  
  const results: ExtendedModerationResult[] = [];
  const batchSize = 10;  // Process in chunks
  
  for (let i = 0; i < texts.length; i += batchSize) {
    const batch = texts.slice(i, i + batchSize);
    
    // Process batch in parallel
    const batchResults = await Promise.all(
      batch.map(text => moderator.moderate(text))
    );
    
    results.push(...batchResults);
    
    // Progress update
    console.log(`Processed ${Math.min(i + batchSize, texts.length)}/${texts.length}`);
    
    // Rate limiting pause between batches
    if (i + batchSize < texts.length) {
      await new Promise(r => setTimeout(r, 1000));
    }
  }
  
  return results;
}

// Usage: Scan existing content
const comments = await db.comments.findMany({ moderated: false });
const results = await moderateBatch(comments.map(c => c.text));

for (let i = 0; i < results.length; i++) {
  if (results[i].action === 'deny') {
    await db.comments.update({
      where: { id: comments[i].id },
      data: { hidden: true, moderationReason: 'flagged' },
    });
  }
}

// Development: More verbose, log everything
const devModerator = new Moderator({
  provider: 'local-only',  // Free, no API calls
  denyThreshold: 0.8,  // More lenient
  normalizeText: true,
  analyzeContext: true,
});

// Production: Balanced settings
const prodModerator = new Moderator({
  provider: 'openai',
  openaiApiKey: process.env.OPENAI_API_KEY,
  denyThreshold: 0.7,
  confidenceThreshold: 0.7,
  fastPath: {
    enabled: true,
    localBlockThreshold: 0.85,
    localAllowThreshold: 0.10,
  },
  council: {
    enabled: true,
    members: ['anthropic', 'gemini'],
    escalateMin: 0.30,
    escalateMax: 0.70,
  },
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  googleApiKey: process.env.GOOGLE_API_KEY,
});

// Strict: For high-risk content (kids platform, etc.)
const strictModerator = new Moderator({
  provider: 'openai',
  openaiApiKey: process.env.OPENAI_API_KEY,
  denyThreshold: 0.5,  // Lower threshold = more blocks
  confidenceThreshold: 0.8,  // Higher confidence required
  fastPath: {
    enabled: true,
    alwaysCheckCategories: [
      'child_safety',
      'self_harm',
      'threats',
      'violence',
    ],
  },
});

class MonitoredModerator extends Moderator {
  private stats = {
    total: 0,
    allowed: 0,
    denied: 0,
    escalated: 0,
    averageLatency: 0,
    tierUsage: {
      local: 0,
      api: 0,
      council: 0,
    },
  };
  
  async moderate(text: string, options?) {
    const start = Date.now();
    const result = await super.moderate(text, options);
    const latency = Date.now() - start;
    
    // Update stats
    this.stats.total++;
    this.stats[result.action]++;
    this.stats.tierUsage[result.tierInfo.tier]++;
    
    // Rolling average
    this.stats.averageLatency = 
      (this.stats.averageLatency * (this.stats.total - 1) + latency) / 
      this.stats.total;
    
    // Log high-severity cases
    if (result.severity > 0.9) {
      console.warn('High severity content:', {
        text: result.original,
        severity: result.severity,
        categories: result.categories,
      });
    }
    
    return result;
  }
  
  getStats() {
    return {
      ...this.stats,
      fastPathEfficiency: 
        (this.stats.tierUsage.local / this.stats.total) * 100,
    };
  }
}

// Periodic reporting
setInterval(() => {
  const stats = moderator.getStats();
  console.log('Moderation Stats:', stats);
  // Send to monitoring service (DataDog, CloudWatch, etc.)
}, 60000);

// Test API connection
import { Moderator } from 'council-mod';

const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
});

try {
  const result = await moderator.moderate("test");
  console.log('API working:', result.tierInfo.tier);
} catch (error) {
  console.error('API error:', error.message);
  // Check: Is OPENAI_API_KEY set? Is it valid? Do you have credits?
}

// Check which tier is being used
const result = await moderator.moderate("text");
console.log('Tier:', result.tierInfo.tier);
console.log('Latency:', result.processingTimeMs);

// If always hitting API/council:
// - Enable fast-path
// - Adjust thresholds
// - Use quickCheck() for high-volume scenarios

// Adjust thresholds
const moderator = new Moderator({
  openaiApiKey: process.env.OPENAI_API_KEY,
  denyThreshold: 0.8,  // Increase (was 0.7)
  confidenceThreshold: 0.6,  // Decrease (was 0.7)
  // More content will escalate instead of deny
});

// Always provide context when available
const result = await moderator.moderate(newMessage, {
  context: previousMessages.map(m => m.text),
  userId: user.id,
  platform: 'chat',
});

// Context helps disambiguate:
// - Reclaimed language
// - Quoted speech
// - Educational discussion
// - Cultural differences