// governance-config.js - Define compliance rules before building features
const governanceConfig = {
  dataRetention: {
    conversationLogs: 90, // days
    voiceBiometrics: 30,
    piiData: 7,
    auditTrails: 2555 // 7 years for GDPR
  },
  consent: {
    required: ['voice_recording', 'data_processing', 'biometric_analysis'],
    explicitOptIn: true,
    withdrawalGracePeriod: 24 // hours
  },
  monitoring: {
    piiDetectionThreshold: 0.85,
    anomalyAlertThreshold: 3, // suspicious patterns
    complianceCheckInterval: 3600000 // 1 hour in ms
  },
  llmGuardrails: {
    maxTokensPerRequest: 4096,
    contentFilters: ['pii', 'financial', 'health'],
    responseValidation: true,
    fallbackBehavior: 'terminate_gracefully'
  },
  auditEvents: [
    'consent_granted',
    'consent_withdrawn',
    'pii_detected',
    'data_accessed',
    'model_inference',
    'policy_violation'
  ]
};

module.exports = governanceConfig;

// consent-validator.js - Check consent BEFORE call starts
async function validateConsent(userId, requiredConsents) {
  const userConsents = await db.query(
    'SELECT consent_type, granted_at, withdrawn_at FROM user_consents WHERE user_id = $1',
    [userId]
  );
  
  const activeConsents = userConsents.rows.filter(c => 
    !c.withdrawn_at && 
    (Date.now() - c.granted_at) < 31536000000 // 1 year expiry
  );
  
  const missingConsents = requiredConsents.filter(required =>
    !activeConsents.some(c => c.consent_type === required)
  );
  
  if (missingConsents.length > 0) {
    await logAuditEvent({
      event: 'consent_missing',
      userId,
      missingConsents,
      action: 'call_blocked'
    });
    throw new Error(`Missing consents: ${missingConsents.join(', ')}`);
  }
  
  return true;
}

// pii-detector.js - Real-time PII scanning with redaction
const piiPatterns = {
  ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
  creditCard: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
  email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g
};

async function scanForPII(transcript, sessionId) {
  let detectedPII = [];
  let redactedText = transcript;
  
  for (const [type, pattern] of Object.entries(piiPatterns)) {
    const matches = transcript.match(pattern);
    if (matches) {
      detectedPII.push({ type, count: matches.length });
      redactedText = redactedText.replace(pattern, `[${type.toUpperCase()}_REDACTED]`);
    }
  }
  
  if (detectedPII.length > 0) {
    await logAuditEvent({
      event: 'pii_detected',
      sessionId,
      piiTypes: detectedPII,
      redactionApplied: true,
      timestamp: Date.now()
    });
  }
  
  return { redactedText, detectedPII };
}

// llm-guardrails.js - Validate LLM responses before voice synthesis
async function validateLLMResponse(response, context) {
  const violations = [];
  
  // Check for PII in model output
  const { detectedPII } = await scanForPII(response, context.sessionId);
  if (detectedPII.length > 0) {
    violations.push({ type: 'pii_in_output', details: detectedPII });
  }
  
  // Verify response doesn't exceed token budget
  const tokenCount = response.split(/\s+/).length * 1.3; // rough estimate
  if (tokenCount > governanceConfig.llmGuardrails.maxTokensPerRequest) {
    violations.push({ type: 'token_limit_exceeded', tokenCount });
  }
  
  // Content filter check
  const contentFlags = await checkContentFilters(response);
  if (contentFlags.length > 0) {
    violations.push({ type: 'content_policy_violation', flags: contentFlags });
  }
  
  if (violations.length > 0) {
    await logAuditEvent({
      event: 'policy_violation',
      sessionId: context.sessionId,
      violations,
      action: 'response_blocked'
    });
    
    return {
      allowed: false,
      fallbackResponse: "I apologize, but I cannot provide that information. Let me connect you with a human agent."
    };
  }
  
  return { allowed: true, response };
}

// compliance-test.js - Automated governance validation
async function runCompli

### System Diagram

Audio processing pipeline from microphone input to speaker output.

```mermaid
graph LR
    Input[Microphone]
    Buffer[Audio Buffer]
    VAD[Voice Activity Detection]
    STT[Speech-to-Text]
    NLU[Intent Detection]
    LLM[Response Generation]
    TTS[Text-to-Speech]
    Output[Speaker]
    ErrorHandler[Error Handler]
    Retry[Retry Logic]
    
    Input -->|Raw Audio| Buffer
    Buffer -->|Buffered Audio| VAD
    VAD -->|Detected Speech| STT
    VAD -->|Silence Detected| ErrorHandler
    STT -->|Transcribed Text| NLU
    STT -->|Transcription Error| ErrorHandler
    NLU -->|Intent Data| LLM
    NLU -->|Intent Error| ErrorHandler
    LLM -->|Generated Response| TTS
    LLM -->|Generation Error| ErrorHandler
    TTS -->|Synthesized Speech| Output
    TTS -->|Synthesis Error| ErrorHandler
    ErrorHandler -->|Handle Error| Retry
    Retry -->|Retry Process| Buffer

// Test consent validation with real-world edge cases
async function testConsentScenarios() {
  const testCases = [
    { userId: 'user_123', consents: ['voice_recording'], expected: true },
    { userId: 'user_456', consents: [], expected: false }, // No consent
    { userId: 'user_789', consents: ['expired_consent'], expected: false }, // Expired
    { userId: 'user_000', consents: null, expected: false } // Null handling
  ];

  for (const test of testCases) {
    try {
      const result = await validateConsent(test.userId, test.consents);
      console.assert(result === test.expected, 
        `FAILED: User ${test.userId} - Expected ${test.expected}, got ${result}`);
    } catch (error) {
      console.error(`Consent validation crashed for ${test.userId}:`, error);
    }
  }
}

// Production barge-in handler with PII redaction
async function handleInterruption(event) {
  const { userId, partialTranscript, audioBufferState } = event;
  
  // Validate consent before processing interruption
  const activeConsents = await validateConsent(userId, ['voice_processing', 'data_retention']);
  if (activeConsents.missingConsents.length > 0) {
    return { action: 'terminate', reason: 'consent_withdrawn' };
  }
  
  // Flush audio buffer and redact PII from partial output
  const redactedText = scanForPII(audioBufferState.partialOutput);
  
  // Log compliant audit event
  await logAuditEvent({
    event: 'barge_in_detected',
    userId: userId,
    timestamp: Date.now(),
    redactedContext: redactedText.redactedText,
    piiDetected: redactedText.detectedPII.length > 0,
    consentStatus: activeConsents.valid
  });
  
  // Validate LLM response before resuming
  const llmResponse = await generateResponse(partialTranscript);
  const violations = validateLLMResponse(llmResponse);
  
  if (violations.contentFlags.length > 0) {
    return { action: 'fallback', response: governanceConfig.llmGuardrails.fallbackBehavior.fallbackResponse };
  }
  
  return { action: 'resume', response: llmResponse };
}

{
  "timestamp": 1704067200000,
  "event": "barge_in_detected",
  "userId": "user_abc123",
  "partialOutput": "[REDACTED_10_DIGITS]",
  "piiDetected": true,
  "consentStatus": "valid",
  "latency_ms": 87,
  "action": "audio_buffer_flushed"
}

// Cache consent with 5-minute TTL, not session-based
const consentCache = new Map();
const CONSENT_TTL = 5 * 60 * 1000; // 5 minutes

async function validateConsent(userId, requiredConsents) {
  const cached = consentCache.get(userId);
  if (cached && Date.now() - cached.timestamp < CONSENT_TTL) {
    return cached.consents;
  }
  
  // Fetch fresh consent state from database
  const activeConsents = await db.query(
    'SELECT consent_type FROM user_consents WHERE user_id = $1 AND revoked_at IS NULL',
    [userId]
  );
  
  const missingConsents = requiredConsents.filter(
    type => !activeConsents.some(c => c.consent_type === type)
  );
  
  if (missingConsents.length > 0) {
    throw new Error(`Missing consents: ${missingConsents.join(', ')}`);
  }
  
  consentCache.set(userId, { 
    consents: activeConsents, 
    timestamp: Date.now() 
  });
  return activeConsents;
}

function scanForPII(text) {
  const piiPatterns = {
    ssn: /\b\d{3}[\s-]?\d{2}[\s-]?\d{4}\b/g, // Handles spaces/dashes
    creditCard: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
    partialCard: /(?:card|ending|last\s+four)[\s:]+(\d{4})/gi // "card ending in 1234"
  };
  
  const detectedPII = [];
  let redactedText = text;
  
  for (const [type, pattern] of Object.entries(piiPatterns)) {
    const matches = text.match(pattern);
    if (matches) {
      detectedPII.push({ type, count: matches.length });
      redactedText = redactedText.replace(pattern, '[REDACTED]');
    }
  }
  
  return { detectedPII, redactedText };
}

async function validateLLMResponse(llmResponse) {
  const violations = [];
  const contentFlags = governanceConfig.llmGuardrails.contentFilters;
  
  // Check token limits (cost control)
  const tokenCount = llmResponse.split(/\s+/).length;
  if (tokenCount > governanceConfig.llmGuardrails.maxTokensPerRequest) {
    violations.push(`Exceeded token limit: ${tokenCount}`);
  }
  
  // Detect medical/legal advice patterns
  if (contentFlags.includes('medical_advice')) {
    if (/\b(diagnose|prescribe|treatment for)\b/i.test(llmResponse)) {
      violations.push('Medical advice detected in output');
    }
  }
  
  if (violations.length > 0) {
    return { 
      allowed: false, 
      fallbackResponse: governanceConfig.llmGuardrails.fallbackBehavior 
    };
  }
  
  return { allowed: true, response: llmResponse };
}

const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

// Governance configuration from previous sections
const governanceConfig = {
  dataRetention: { conversationLogs: 90, voiceBiometrics: 30, piiData: 0 },
  consent: { required: ['voice_recording', 'data_processing'], withdrawalGracePeriod: 24 },
  monitoring: { piiDetectionThreshold: 0.85, anomalyAlertThreshold: 3, complianceCheckInterval: 3600 },
  llmGuardrails: { maxTokensPerRequest: 4096, contentFilters: ['profanity', 'pii', 'bias'], fallbackBehavior: 'terminate' }
};

// In-memory consent cache (use Redis in production)
const consentCache = new Map();
const CONSENT_TTL = 3600000; // 1 hour

// PII detection patterns
const piiPatterns = {
  ssn: /\b\d{3}-\d{2}-\d{4}\b/g,
  creditCard: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g,
  email: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
  phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g
};

// Validate user consent before call starts
function validateConsent(userId, requiredConsents) {
  const cached = consentCache.get(userId);
  if (cached && Date.now() - cached.timestamp < CONSENT_TTL) {
    return cached.consents;
  }
  
  // In production: query consent database
  const userConsents = { voice_recording: true, data_processing: true, analytics: false };
  const activeConsents = requiredConsents.filter(type => userConsents[type]);
  const missingConsents = requiredConsents.filter(type => !userConsents[type]);
  
  if (missingConsents.length > 0) {
    throw new Error(`Missing required consents: ${missingConsents.join(', ')}`);
  }
  
  consentCache.set(userId, { consents: userConsents, timestamp: Date.now() });
  return userConsents;
}

// Real-time PII detection and redaction
function scanForPII(text) {
  const detectedPII = [];
  let redactedText = text;
  
  Object.entries(piiPatterns).forEach(([type, pattern]) => {
    const matches = text.match(pattern);
    if (matches) {
      detectedPII.push({ type, count: matches.length });
      redactedText = redactedText.replace(pattern, `[REDACTED_${type.toUpperCase()}]`);
    }
  });
  
  return { detectedPII, redactedText, hasPII: detectedPII.length > 0 };
}

// LLM response validation with token limits
function validateLLMResponse(response) {
  const tokenCount = response.split(/\s+/).length; // Simplified token count
  const violations = [];
  
  if (tokenCount > governanceConfig.llmGuardrails.maxTokensPerRequest) {
    violations.push(`Token limit exceeded: ${tokenCount}/${governanceConfig.llmGuardrails.maxTokensPerRequest}`);
  }
  
  const piiScan = scanForPII(response);
  if (piiScan.hasPII) {
    violations.push(`PII detected in LLM output: ${piiScan.detectedPII.map(p => p.type).join(', ')}`);
  }
  
  const contentFlags = governanceConfig.llmGuardrails.contentFilters.filter(filter => {
    if (filter === 'profanity') return /\b(damn|hell|crap)\b/i.test(response);
    if (filter === 'bias') return /\b(always|never|all|none)\b/i.test(response);
    return false;
  });
  
  if (contentFlags.length > 0) {
    violations.push(`Content filter triggered: ${contentFlags.join(', ')}`);
  }
  
  return { valid: violations.length === 0, violations, redactedResponse: piiScan.redactedText };
}

// Webhook handler for Retell AI events
app.post('/webhook/retell', (req, res) => {
  const event = req.body;
  
  try {
    // Validate consent on call start
    if (event.type === 'call_started') {
      const consents = validateConsent(event.userId, governanceConfig.consent.required);
      console.log(`[AUDIT] Call started for user ${event.userId} with consents:`, consents);
    }
    
    // Scan transcript for PII in real-time
    if (event.type === 'transcript_partial' || event.type === 'transcript_final') {
      const piiScan = scanForPII(event.transcript);
      
      if (piiScan.hasPII) {
        console.error(`[COMPLIANCE VIOLATION] PII detected in transcript:`, piiScan.detectedPII);
        
        // Terminate call if PII threshold exceeded
        if (piiScan.detectedPII.length >= governanceConfig.monitoring.piiDetectionThreshold) {
          return res.json({
            action: 'terminate_call',
            reason: 'PII_THRESHOLD_EXCEEDED',
            fallbackResponse: 'I apologize, but I cannot continue this conversation due to sensitive information being shared.'
          });
        }
      }
    }
    
    // Validate LLM responses before synthesis
    if (event.type === 'llm_response') {
      const validation = validateLLMResponse(event.response);
      
      if (!validation.valid) {
        console.error(`[LLM GUARDRAIL] Response blocked:`, validation.violations);
        
        if (governanceConfig.llmGuardrails.fallbackBehavior === 'terminate') {
          return res.json({
            action: 'terminate_call',
            reason: 'LLM_GUARDRAIL_VIOLATION',
            fallbackResponse: 'I need to end this call. Please contact support for assistance.'
          });
        }
        
        return res.json({
          action: 'override_response',
          response: validation.redactedResponse
        });
      }
    }
    
    res.json({ status: 'processed' });
    
  } catch (error) {
    console.error(`[ERROR] Webhook processing failed:`, error.message);
    
    if (error.message.includes('Missing required consents')) {
      return res.status(403).json({
        error: 'CONSENT_REQUIRED',
        message: error.message,
        action: 'terminate_call'
      });
    }
    
    res.status(500).json({ error: 'INTERNAL_ERROR' });
  }
});

// Audit log endpoint for compliance reporting
app.get('/audit/logs', (req, res) => {
  const { startDate, endDate, userId, eventType

## FAQ

## Technical Questions

**How do I implement voice biometrics compliance within a Retell AI governance framework?**

Voice biometrics introduces speaker identification data—a biometric identifier under GDPR Article 4(14). Store voice embeddings separately from conversation transcripts. Use `voiceBiometrics` config with explicit consent tracking via `userConsents` array. Implement immediate deletion on consent withdrawal using `withdrawalGracePeriod` (typically 30 days for legal hold). Retell AI's webhook events include speaker confidence scores—log these in `auditTrails` with timestamps for regulatory proof. Never use voice data for secondary purposes (e.g., marketing segmentation) without explicit re-consent.

**What's the difference between data lineage and audit trails for voice agents?**

Data lineage tracks WHERE data flows (user → Retell AI → your server → database → analytics). Audit trails track WHO accessed it, WHEN, and WHY. For compliance, you need both. Configure `auditTrails` with `event`, `action`, `type`, and `userId` fields. Log every PII detection via `scanForPII()`, every consent check via `validateConsent()`, and every LLM response via `validateLLMResponse()`. This creates an unbroken chain proving you followed governance rules—essential for GDPR Article 5(2) accountability.

**How do I handle consent withdrawal mid-conversation?**

When a user says "delete my data," trigger `handleInterruption()` to stop recording immediately. Set `activeConsents[userId]` to false. Within `withdrawalGracePeriod`, flag conversation records for deletion but retain minimal metadata (timestamp, reason) for legal defense. Retell AI webhooks fire on call termination—use this event to initiate async deletion jobs. Never continue processing voice after withdrawal; return `fallbackResponse` from `llmGuardrails` config.

## Performance

**Does PII detection add latency to real-time conversations?**

Yes. `scanForPII()` with regex patterns (`piiPatterns`) adds 15-50ms per transcript chunk depending on pattern complexity. Use `piiDetectionThreshold` (0.7-0.9 confidence) to reduce false positives. Run detection asynchronously—don't block the STT-to-LLM pipeline. Store results in `detectedPII` cache with TTL matching `CONSENT_TTL`. For high-volume deployments, batch PII checks every 500ms instead of per-utterance.

**What's the latency impact of LLM guardrails validation?**

`validateLLMResponse()` adds 20-100ms depending on `maxTokensPerRequest` and `contentFilters` complexity. Use early rejection: check `contentFlags` before full validation. Cache guardrail decisions for identical prompts (same user, same context). Implement timeout fallback—if validation exceeds 200ms, return `fallbackBehavior` (e.g., "I can't answer that") rather than hanging.

## Platform Comparison

**Should I use Retell AI's native consent tracking or build custom logic?**

Retell AI doesn't natively enforce GDPR consent—it's a voice API, not a compliance engine. Build custom `governanceConfig` with `consent.required` flags and `userConsents` tracking. Use Retell AI webhooks to trigger your consent validation. Twilio's Compliance module (for SMS/voice) handles some consent workflows, but for voice agents, you own the responsibility. Implement `auditTrails` logging in your backend, not in Retell AI.

**Can I use Twilio for consent management instead of custom code?**

Partially. Twilio's Messaging Service enforces SMS opt-in via `consent.required` flags, but voice agent consent is different—it requires real-time decision-making during calls. Use Twilio for pre-call SMS consent ("Reply YES to consent to voice call"), then validate in Retell AI via webhook before starting the agent. Don't rely on Twilio alone; implement `validateConsent()` in your governance layer.

**How do I audit Retell AI vs. Twilio data separately?**

Log separately. Retell AI calls → `auditTrails` with `type: "voice_agent"`. Twilio calls → separate logs with `type: "sms"` or `type

## Resources

**Retell AI Documentation**
- [Retell AI API Reference](https://docs.retellai.com) – Voice agent setup, LLM integration, webhook handling
- [Retell AI GitHub](https://github.com/RetellAI) – Open-source examples, SDKs

**Compliance & Governance**
- [GDPR Official Text](https://gdpr-info.eu/) – Articles 5 (data principles), 7 (consent), 17 (right to erasure)
- [NIST AI Risk Management Framework](https://nvlpubs.nist.gov/nistpubs/ai/NIST.AI.600-1.pdf) – Governance, audit trails, LLM guardrails

**Voice Biometrics & Data Lineage**
- [ISO/IEC 30107-3](https://www.iso.org/standard/72032.html) – Voice presentation attack detection
- [W3C Data Catalog Vocabulary](https://www.w3.org/TR/vocab-dcat-3/) – Data lineage for conversational AI systems

**Twilio Integration**
- [Twilio Voice API Docs](https://www.twilio.com/docs/voice) – Call recording, compliance webhooks
- [Twilio Compliance Guide](https://www.twilio.com/en-us/compliance) – GDPR, HIPAA, PCI-DSS

**Monitoring & Audit**
- [OpenTelemetry Specification](https://opentelemetry.io/docs/specs/otel/) – Structured audit trail instrumentation
- [OWASP Top 10 for LLMs](https://owasp.org/www-project-top-10-for-large-language-model-applications/) – Prompt injection, data leakage risks