Pacing Is A Feature: Dynamic Speech Speed Controls Per Context

class PacingController {
  constructor() {
    this.speedProfiles = {
      confirmation_code: 0.80,  // Very slow
      complex_instructions: 0.85,
      critical_warning: 0.85,
      legal_disclaimer: 0.85,
      technical_specs: 0.90,
      standard_response: 1.0,
      simple_confirmation: 1.1,
      acknowledgment: 1.15
    };
    
    this.userPreference = 1.0;  // User's baseline preference
  }
  
  classifyContent(text) {
    // Detect confirmation codes (numbers/letters)
    if (/\b[A-Z0-9]{4,}\b/i.test(text)) {
      return 'confirmation_code';
    }
    
    // Detect warnings
    if (/cannot be undone|permanent|delete|warning|caution/i.test(text)) {
      return 'critical_warning';
    }
    
    // Detect legal/complex language
    if (/hereby|pursuant|notwithstanding|whereas/i.test(text)) {
      return 'legal_disclaimer';
    }
    
    // Detect step-by-step instructions
    if (/first|second|then|next|finally|step \d/i.test(text)) {
      return 'complex_instructions';
    }
    
    // Detect simple confirmations
    if (/^(ok|got it|done|yes|no|sure|yep|nope|alright)[\.\!]?$/i.test(text.trim())) {
      return 'simple_confirmation';
    }
    
    // Detect acknowledgments
    if (/^(uh-huh|mm-hmm|yeah|right|okay)[\.\!]?$/i.test(text.trim())) {
      return 'acknowledgment';
    }
    
    return 'standard_response';
  }
  
  getSpeed(text) {
    const contentType = this.classifyContent(text);
    const baseSpeed = this.speedProfiles[contentType];
    
    // Apply user preference modifier
    return baseSpeed * this.userPreference;
  }
  
  adjustForRepeat(currentSpeed) {
    // If user asks for repeat, slow down
    return Math.max(0.75, currentSpeed - 0.15);
  }
}

const pacer = new PacingController();

// Usage
const response = "Your confirmation code is TX8492KL";
const speed = pacer.getSpeed(response);  // Returns 0.80 (slow)

console.log(`Speaking at ${speed}x speed: "${response}"`);

class VoiceAgentWithPacing {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.pacer = new PacingController();
    this.peerConnection = null;
    this.repeatCount = 0;
  }
  
  async connect() {
    // Set up WebRTC connection to OpenAI Realtime API
    this.peerConnection = new RTCPeerConnection({
      iceServers: [{ urls: 'stun:stun.l.google.com:19302' }]
    });
    
    const stream = await navigator.mediaDevices.getUserMedia({
      audio: {
        echoCancellation: true,
        noiseSuppression: true,
        autoGainControl: true
      }
    });
    
    stream.getTracks().forEach(track => {
      this.peerConnection.addTrack(track, stream);
    });
    
    // Handle incoming audio with pacing control
    this.peerConnection.ontrack = (event) => {
      this.playWithPacing(event.streams[0]);
    };
    
    // ... WebRTC setup continues
  }
  
  async speak(text, options = {}) {
    // Determine speech speed
    const speed = options.speed || this.pacer.getSpeed(text);
    
    // Send to OpenAI with speech parameters
    await this.sendMessage({
      type: 'response.create',
      response: {
        modalities: ['audio', 'text'],
        instructions: `Speak this at ${speed}x speed: "${text}"`,
        voice: 'alloy',
        output_audio_format: 'pcm16'
      }
    });
    
    // Log pacing decision
    console.log(`[Pacing] "${text.substring(0, 50)}..." at ${speed}x`);
  }
  
  async handleUserInput(transcript) {
    // Detect if user is asking for repeat
    if (/what|repeat|again|didn't catch|say that/i.test(transcript)) {
      this.repeatCount++;
      
      // Slow down on repeats
      const slowedSpeed = this.pacer.adjustForRepeat(
        this.lastSpeed || 1.0
      );
      
      await this.speak(this.lastResponse, { speed: slowedSpeed });
      
      console.log(`[Pacing] Repeat requested, slowed to ${slowedSpeed}x`);
    } else {
      this.repeatCount = 0;
      
      // Normal response with adaptive pacing
      const response = await this.generateResponse(transcript);
      this.lastResponse = response;
      this.lastSpeed = this.pacer.getSpeed(response);
      
      await this.speak(response);
    }
  }
  
  setUserPreference(preference) {
    // User can adjust baseline speed: 0.8 = slower, 1.2 = faster
    this.pacer.userPreference = preference;
    console.log(`[Pacing] User preference set to ${preference}x`);
  }
}

// Example usage
const agent = new VoiceAgentWithPacing(process.env.OPENAI_API_KEY);
await agent.connect();

// Different pacing for different content
await agent.speak("Got it!");  // Fast: 1.1x
await agent.speak("Your confirmation code is BX7492KL");  // Slow: 0.80x
await agent.speak("This action cannot be undone");  // Slow: 0.85x

class AdaptivePacingLearner {
  constructor() {
    this.userMetrics = {
      repeatRequests: 0,
      interruptionRate: 0,
      comprehensionSignals: []
    };
  }
  
  recordRepeatRequest() {
    this.userMetrics.repeatRequests++;
    
    // If user asks for repeats frequently, default slower
    if (this.userMetrics.repeatRequests > 3) {
      return { recommendation: 'slower', modifier: 0.90 };
    }
    
    return null;
  }
  
  recordInterruption() {
    this.userMetrics.interruptionRate++;
    
    // If user interrupts frequently, they might want faster pace
    if (this.userMetrics.interruptionRate > 5) {
      return { recommendation: 'faster', modifier: 1.10 };
    }
    
    return null;
  }
  
  recordComprehension(understood) {
    this.userMetrics.comprehensionSignals.push(understood);
    
    // Calculate comprehension rate
    const recentSignals = this.userMetrics.comprehensionSignals.slice(-10);
    const comprehensionRate = recentSignals.filter(s => s).length / recentSignals.length;
    
    if (comprehensionRate < 0.7) {
      return { recommendation: 'slower', modifier: 0.92 };
    } else if (comprehensionRate > 0.95) {
      return { recommendation: 'faster', modifier: 1.05 };
    }
    
    return null;
  }
  
  getRecommendedPacing() {
    // Analyze user behavior and suggest adjustment
    const signals = [
      this.recordRepeatRequest(),
      this.recordInterruption(),
      this.recordComprehension(true)
    ].filter(s => s !== null);
    
    if (signals.length === 0) return 1.0;
    
    // Average the modifiers
    const avgModifier = signals.reduce((sum, s) => sum + s.modifier, 0) / signals.length;
    return avgModifier;
  }
}

import re
from typing import Dict, Literal

class PacingController:
    def __init__(self):
        self.speed_profiles = {
            'confirmation_code': 0.80,
            'complex_instructions': 0.85,
            'critical_warning': 0.85,
            'legal_disclaimer': 0.85,
            'technical_specs': 0.90,
            'standard_response': 1.0,
            'simple_confirmation': 1.1,
            'acknowledgment': 1.15
        }
        self.user_preference = 1.0
    
    def classify_content(self, text: str) -> str:
        """Classify content type to determine appropriate pacing."""
        
        # Confirmation codes
        if re.search(r'\b[A-Z0-9]{4,}\b', text, re.IGNORECASE):
            return 'confirmation_code'
        
        # Warnings
        if re.search(
            r'cannot be undone|permanent|delete|warning|caution',
            text,
            re.IGNORECASE
        ):
            return 'critical_warning'
        
        # Legal language
        if re.search(
            r'hereby|pursuant|notwithstanding|whereas',
            text,
            re.IGNORECASE
        ):
            return 'legal_disclaimer'
        
        # Instructions
        if re.search(
            r'first|second|then|next|finally|step \d',
            text,
            re.IGNORECASE
        ):
            return 'complex_instructions'
        
        # Simple confirmations
        if re.match(
            r'^(ok|got it|done|yes|no|sure|yep|nope|alright)[\.\!]?$',
            text.strip(),
            re.IGNORECASE
        ):
            return 'simple_confirmation'
        
        return 'standard_response'
    
    def get_speed(self, text: str) -> float:
        """Get recommended speech speed for given text."""
        content_type = self.classify_content(text)
        base_speed = self.speed_profiles[content_type]
        return base_speed * self.user_preference
    
    def adjust_for_repeat(self, current_speed: float) -> float:
        """Slow down if user requested repeat."""
        return max(0.75, current_speed - 0.15)
    
    def set_user_preference(self, preference: float):
        """Set user's baseline speed preference (0.8 - 1.2)."""
        self.user_preference = max(0.8, min(1.2, preference))

# Usage example
pacer = PacingController()

# Different content types
texts = [
    "Got it!",
    "Your code is TX8492KL",
    "This action cannot be undone",
    "First, open the settings menu. Then, click on advanced options."
]

for text in texts:
    speed = pacer.get_speed(text)
    content_type = pacer.classify_content(text)
    print(f"{speed}x [{content_type}]: {text}")

class UserPacingControls {
  renderSpeedControl() {
    return `
      <div class="pacing-control">
        <label>Voice Speed Preference:</label>
        <input 
          type="range" 
          min="0.8" 
          max="1.2" 
          step="0.1" 
          value="1.0"
          oninput="updatePacing(this.value)"
        />
        <span id="speed-display">1.0x</span>
      </div>
    `;
  }
  
  updatePacing(value) {
    const speed = parseFloat(value);
    agent.setUserPreference(speed);
    document.getElementById('speed-display').textContent = `${speed}x`;
    
    // Save to user preferences
    localStorage.setItem('voice_speed_preference', speed);
  }
  
  loadUserPreference() {
    const saved = localStorage.getItem('voice_speed_preference');
    if (saved) {
      const speed = parseFloat(saved);
      agent.setUserPreference(speed);
      return speed;
    }
    return 1.0;
  }
}

async function speakWithPauses(segments) {
  for (let segment of segments) {
    await agent.speak(segment.text, { speed: segment.speed });
    if (segment.pause) {
      await sleep(segment.pause);  // Pause in milliseconds
    }
  }
}

// Example
await speakWithPauses([
  { text: "Your confirmation code is", speed: 1.0, pause: 300 },
  { text: "B X 7 4 9 2 K L", speed: 0.75, pause: 500 },
  { text: "I've also sent this to your email", speed: 1.0, pause: 0 }
]);