function sendResponse(message, channel) {
  let typing_duration = estimateTypingTime(message)

  showTypingIndicator()
  wait(typing_duration)
  hideTypingIndicator()
  sendMessage(message)
}

function estimateTypingTime(message) {
  // ~200-300ms per word, with minimum
  let words = message.split(' ').length
  let base_time = words * 250  // ms
  return Math.max(1000, Math.min(base_time, 5000))
}

"Thanks for reaching out! I'd be happy to help you understand our pricing. We offer three tiers: Basic at $29/month, Pro at $79/month, and Enterprise with custom pricing. Each tier includes different features. Would you like me to explain the differences, or do you have specific questions about any tier?"

[Message 1, 1s delay]
"Thanks for reaching out! I'd be happy to help with pricing."

[Message 2, 2s delay]
"We have three tiers: Basic ($29/mo), Pro ($79/mo), and Enterprise (custom)."

[Message 3, 1.5s delay]
"Want me to break down what's included in each, or do you have a specific question?"

function humanizedDelay(base_ms) {
  // Add ±20% randomization
  let variance = base_ms * 0.2
  let random = (Math.random() - 0.5) * 2 * variance
  return base_ms + random
}

async function respondWithDelay(message, context) {
  let delay = calculateDelay(message, context)

  // Show typing indicator for chat
  if (context.channel === 'chat') {
    showTypingIndicator(context.session)
  }

  await sleep(delay)

  if (context.channel === 'chat') {
    hideTypingIndicator(context.session)
  }

  return sendMessage(message, context)
}

function calculateDelay(message, context) {
  let base = getBaseDelay(context.channel)
  let length_factor = Math.min(message.length / 50, 3)
  let complexity_factor = context.is_complex ? 1.5 : 1

  let delay = base * length_factor * complexity_factor
  return humanizedDelay(delay)
}

let message_queue = []
let is_sending = false

async function queueMessage(message, delay) {
  message_queue.push({ message, delay })

  if (!is_sending) {
    is_sending = true
    await processQueue()
    is_sending = false
  }
}

async function processQueue() {
  while (message_queue.length > 0) {
    let { message, delay } = message_queue.shift()
    await sleep(delay)
    await sendMessage(message)
  }
}

async function getResponseWithTimeout(input, timeout_ms) {
  let response_promise = generateResponse(input)
  let timeout_promise = sleep(timeout_ms).then(() => {
    throw new Error('timeout')
  })

  try {
    return await Promise.race([response_promise, timeout_promise])
  } catch (e) {
    return "I'm taking a bit longer than usual. Give me a moment..."
  }
}