Agente de voz no WhatsApp: latência, interrupção (barge-in) e silêncio

Um agente de voz no WhatsApp parece natural quando responde em cerca de um segundo, para de falar quando o cliente interrompe e sabe lidar com silêncio. Os três dependem de fazer tudo em streaming, enviar a fala da IA em pedaços pequenos e ter uma detecção de fala bem ajustada. Na API não oficial da WAME, a voz do cliente chega pelo evento call-audio do Socket.IO e a fala da IA sai pelo evento call-audio-in, ambos em PCM 16 kHz — o resto é engenharia do seu lado.

Se você ainda não montou o agente, comece pela arquitetura em IA para atender ligação no WhatsApp. Aqui o assunto é o que separa um protótipo que funciona de um agente que ninguém percebe que é lento.

A camada não oficial da WAME é independente e não é afiliada, endossada ou suportada pelo WhatsApp ou pela Meta. O uso é de responsabilidade de quem envia.

O orçamento de latência

Latência de voz é a soma de várias etapas, e cada uma come uma fatia:

Somando tudo em modo sequencial — esperar a transcrição inteira, depois a resposta inteira, depois o áudio inteiro — é fácil passar de três segundos. O cliente acha que a ligação caiu.

O segredo é não esperar nenhuma etapa terminar:

• a transcrição vai sendo feita enquanto a pessoa fala;
• o modelo começa a gerar assim que o texto final chega, e você pega a resposta token a token;
• assim que a primeira frase da resposta está pronta, ela vai para a voz sintética;
• o áudio da primeira frase começa a tocar enquanto a segunda ainda está sendo gerada.

Com isso, o tempo percebido deixa de ser a soma das etapas e passa a ser o tempo até a primeira frase soar.

Fatiar a resposta por frase

O truque mais barato para cortar latência é sintetizar frase por frase:

async function falarEmStreaming(callId, tokens) {
  let frase = '';
  for await (const t of tokens) {       // resposta do modelo, token a token
    frase += t;
    if (/[.!?…]\s*$/.test(frase) && frase.length > 20) {
      const pcm = await sintetizar(frase); // PCM16 16 kHz
      enfileirar(callId, pcm);
      frase = '';
    }
  }
  if (frase.trim()) enfileirar(callId, await sintetizar(frase));
}

O frase.length > 20 evita sintetizar "Ok." sozinho, o que soa picotado. Ajuste com ouvido, não com planilha.

Se o seu provedor devolve áudio a 24 kHz ou 48 kHz, reamostre para 16 kHz antes de enfileirar. Áudio na taxa errada toca acelerado ou lento — é o bug mais comum da primeira versão.

A fila de reprodução

Enviar um áudio inteiro de dez segundos de uma vez parece prático, mas mata a interrupção: o que já foi enviado para a ligação vai tocar até o fim. A solução é ter uma fila local e alimentar a ligação aos poucos, em pedaços de algumas dezenas de milissegundos, no ritmo em que o áudio é tocado:

const PEDACO_MS = 40;
const BYTES = 16000 * 2 * (PEDACO_MS / 1000); // 16 kHz, 16 bits

function criarReprodutor(socket, callId) {
  let fila = [];
  let timer = null;

  function tick() {
    const pedaco = fila.shift();
    if (!pedaco) { clearInterval(timer); timer = null; return; }
    socket.emit('call-audio-in', { callId, pcm: pedaco.toString('base64') });
  }

  return {
    enfileirar(pcm) {
      for (let i = 0; i < pcm.length; i += BYTES) fila.push(pcm.subarray(i, i + BYTES));
      if (!timer) timer = setInterval(tick, PEDACO_MS);
    },
    parar() {            // barge-in: descarta o que ainda não foi enviado
      fila = [];
      clearInterval(timer);
      timer = null;
    },
    get falando() { return timer !== null; },
  };
}

Com pedaços de 40 ms enviados no ritmo real, o máximo que ainda toca depois de um parar() é o que já estava a caminho — uma fração de segundo. É isso que faz a interrupção parecer instantânea.

Interrupção (barge-in)

O cliente vai interromper. Ele já entendeu, quer corrigir, ou a IA errou o nome dele. Um agente que continua falando por cima perde a pessoa.

A lógica é simples: enquanto a IA fala, continue ouvindo. Se o detector perceber voz do cliente por mais que um instante, pare a reprodução e volte a escutar.

socket.on('call-audio', ({ callId, pcm }) => {
  const c = chamadas.get(callId);
  if (!c) return;
  const buf = Buffer.from(pcm, 'base64');

  if (c.reprodutor.falando && temVoz(buf)) {
    c.vozDuranteFala += PEDACO_MS;
    if (c.vozDuranteFala > 250) {   // voz sustentada, não um "hum"
      c.reprodutor.parar();
      c.cancelarResposta?.();       // aborta a geração em andamento
      c.vozDuranteFala = 0;
    }
  } else {
    c.vozDuranteFala = 0;
  }
  c.detector.alimentar(buf);
});

Dois cuidados:

• Não interrompa por qualquer ruído. Exija voz sustentada por um tempo curto; um "aham" ou uma tosse não deveria cortar a IA.
• Cancele também a geração. Se o modelo ainda está produzindo a resposta antiga, aborte — senão, meio segundo depois, a IA volta a falar do assunto que o cliente acabou de interromper.

E registre no histórico que a resposta foi interrompida. Na próxima rodada, o modelo precisa saber que o cliente não ouviu tudo.

Detecção de fala e silêncio

O detector de fala (VAD) decide duas coisas: quando a pessoa começou e quando terminou. Os parâmetros que mais importam, conceitualmente:

• Limiar de voz: a partir de que nível um pedaço de áudio conta como fala. Alto demais ignora quem fala baixo; baixo demais trata o barulho da rua como fala.
• Silêncio de fim de fala: quanto tempo de silêncio confirma que a pessoa terminou. Curto demais corta quem faz pausa para pensar; longo demais soma latência em toda resposta. A faixa de algumas centenas de milissegundos é um bom ponto de partida.
• Duração mínima: trechos muito curtos (um estalo, um "é") não viram pergunta para o modelo.

Um detector por energia serve para protótipo. Em produção, use um VAD baseado em modelo, que distingue voz de ruído muito melhor. E teste com o áudio real das ligações: viva-voz, carro, loja movimentada.

O silêncio do lado do cliente

Silêncio longo também precisa de regra:

• Depois de uma pergunta da IA, alguns segundos sem resposta: repita a pergunta de forma mais curta ("Ainda está aí? Pode me dizer o dia que prefere?").
• Segundo silêncio longo: ofereça continuar por mensagem ("Vou te mandar as opções por WhatsApp, tudo bem?") e encerre com POST /{key}/call/end.
• Silêncio total desde o início: a ligação pode ter sido atendida por engano. Encerre com educação depois de uma tentativa.

Deixar a ligação aberta sem ninguém ocupa uma sessão de áudio à toa. A plataforma limita quantas sessões de mídia rodam ao mesmo tempo e limpa as ociosas; é melhor o seu código encerrar primeiro.

Enchimento: "só um instante"

Quando a IA precisa consultar algo (agenda, pedido, estoque), a resposta pode demorar mais. Em vez de silêncio, toque uma frase curta pré-gravada: "Deixa eu ver aqui…".

Gere esses áudios uma vez, guarde o PCM em memória e enfileire na hora. Como são poucos e fixos, não custam síntese a cada ligação. Para arquivos que você não quer converter, POST /{key}/call/{callId}/audio com url aceita qualquer formato e a API converte para o formato da chamada — só que ele não é interrompível pela sua fila local, então use para frases curtas.

Eco

Em algumas ligações, principalmente em viva-voz, a voz da IA volta pelo microfone do cliente. O detector ouve essa voz e acha que o cliente está falando: a IA interrompe a si mesma.

Formas de lidar:

• Exija voz sustentada mais longa para barge-in enquanto a IA fala.
• Compare o que chegou com o que você acabou de enviar; se o trecho transcrito for igual ao começo da fala da IA, descarte.
• Mantenha o volume da voz sintética moderado; áudio estourado gera mais eco.

Não existe solução perfeita; o objetivo é que o eco não dispare interrupções falsas com frequência.

E os modelos speech-to-speech?

Modelos que recebem fala e devolvem fala em tempo real juntam transcrição, raciocínio e voz numa etapa só, e costumam ter a menor latência. Vale considerar. Três cuidados:

• Você ainda cuida da ponte: converter o PCM 16 kHz para o formato do provedor e de volta, com reamostragem se a taxa for diferente.
• Interrupção e silêncio continuam sendo seus: o provedor ajuda, mas quem para a fila da ligação é o seu código.
• Registro e ferramentas: confira se você consegue guardar a transcrição e chamar funções do seu sistema com o mesmo controle que tem no fluxo em etapas.

Medir antes de otimizar

Registre, por ligação, quatro tempos: fim da fala do cliente, texto transcrito, primeira frase da resposta, primeiro pedaço de áudio enviado. Com isso você sabe exatamente qual etapa está lenta, em vez de trocar de provedor no escuro. O custo de cada etapa entra na conta em quanto custa um agente de IA no WhatsApp.

Conclusão

Latência, interrupção e silêncio são o que o cliente percebe de um agente de voz — muito mais que a qualidade da voz. As regras que resolvem os três são poucas: streaming em todas as etapas, síntese por frase, fila local enviada em pedaços pequenos pelo call-audio-in, barge-in que esvazia a fila e cancela a geração, e regras claras para silêncio. A API não oficial da WAME entrega o áudio da ligação em tempo real nos dois sentidos, em PCM 16 kHz; com essas peças do seu lado, a conversa fica natural. O agente completo está em IA para atender ligação no WhatsApp, e os endpoints de chamada, na documentação.