Recibir y reproducir el audio de la respuesta
En esta página
Reproducción en streaming
Cuando el agente de voz genera una respuesta, el audio llega en fragmentos codificados en base64 (deltas). Tu aplicación debe decodificarlos, ponerlos en cola y reproducirlos sin interrupciones para que el usuario escuche una respuesta continua y sin huecos.
Arquitectura del reproductor de audio
El principio es sencillo: cada delta de audio que recibes se decodifica y se añade a una cola. Un proceso de reproducción consume esa cola y envía los datos a la salida de audio del sistema:
class AudioStreamPlayer {
constructor(sampleRate = 24000) {
this.audioContext = new AudioContext({ sampleRate });
this.queue = [];
this.isPlaying = false;
this.nextPlayTime = 0;
}
enqueue(pcm16ArrayBuffer) {
// Convertir PCM16 a Float32 para la Web Audio API
const pcm16 = new Int16Array(pcm16ArrayBuffer);
const float32 = new Float32Array(pcm16.length);
for (let i = 0; i < pcm16.length; i++) {
float32[i] = pcm16[i] / 32768.0;
}
const buffer = this.audioContext.createBuffer(
1, float32.length, this.audioContext.sampleRate
);
buffer.getChannelData(0).set(float32);
this.queue.push(buffer);
if (!this.isPlaying) this.playNext();
}
playNext() {
if (this.queue.length === 0) {
this.isPlaying = false;
return;
}
this.isPlaying = true;
const buffer = this.queue.shift();
const source = this.audioContext.createBufferSource();
source.buffer = buffer;
source.connect(this.audioContext.destination);
const now = this.audioContext.currentTime;
const startTime = Math.max(now, this.nextPlayTime);
source.start(startTime);
this.nextPlayTime = startTime + buffer.duration;
source.onended = () => this.playNext();
}
stop() {
this.queue = [];
this.isPlaying = false;
this.nextPlayTime = 0;
}
}
Conexión con los eventos de WebSocket
Así es como conectas el reproductor de audio a los eventos de la API:
const player = new AudioStreamPlayer(24000);
ws.on("message", (data) => {
const event = JSON.parse(data);
switch (event.type) {
case "response.output_audio.delta":
const audioBytes = base64ToArrayBuffer(event.delta);
player.enqueue(audioBytes);
break;
case "response.output_audio.done":
console.log("Respuesta de audio completada");
break;
case "input_audio_buffer.speech_started":
// El usuario interrumpe al agente
player.stop();
ws.send(JSON.stringify({ type: "response.cancel" }));
break;
}
});
function base64ToArrayBuffer(base64) {
const binary = atob(base64);
const bytes = new Uint8Array(binary.length);
for (let i = 0; i < binary.length; i++) {
bytes[i] = binary.charCodeAt(i);
}
return bytes.buffer;
}
Gestión de interrupciones
En una conversación natural, el usuario puede interrumpir al agente hablando mientras este responde. Tu aplicación debe gestionar esto:
- Detectar la interrupción: el evento
speech_startedllega mientras se reproduce el audio. - Detener la reproducción: vaciar la cola de audio y cortar el sonido.
- Cancelar la respuesta: enviar
response.cancelpara que el servidor deje de generar contenido. - Escuchar: el usuario tiene la palabra y el ciclo comienza de nuevo.
Este mecanismo de «barge-in» (interrupción) es esencial para una conversación fluida. Sin él, los usuarios tendrían que esperar a que el agente terminara de hablar antes de poder responder.
Reproductor de audio en Python
Para una aplicación en Python, puedes usar pyaudio para la reproducción:
import pyaudio
import base64
import asyncio
from collections import deque
class AudioPlayer:
def __init__(self, rate=24000):
self.p = pyaudio.PyAudio()
self.stream = self.p.open(
format=pyaudio.paInt16,
channels=1,
rate=rate,
output=True
)
self.queue = deque()
def enqueue(self, base64_audio):
audio_bytes = base64.b64decode(base64_audio)
self.queue.append(audio_bytes)
def play_all(self):
while self.queue:
chunk = self.queue.popleft()
self.stream.write(chunk)
def stop(self):
self.queue.clear()
Mostrar la transcripción simultáneamente
Mientras se reproduce el audio, puedes mostrar la transcripción de la respuesta en tiempo real mediante los eventos response.output_audio_transcript.delta. Así, los usuarios pueden leer lo que dice el agente, lo cual resulta útil en entornos ruidosos y para mejorar la accesibilidad:
let currentTranscript = "";
case "response.output_audio_transcript.delta":
currentTranscript += event.delta;
updateTranscriptDisplay(currentTranscript);
break;
Puntos clave
- El audio de la respuesta llega en fragmentos base64 a través de
response.output_audio.delta. - Usa una cola de audio para garantizar una reproducción continua sin huecos.
- Gestiona las interrupciones (barge-in) deteniendo la reproducción y cancelando la respuesta.
- Muestra la transcripción junto al audio para mejorar la accesibilidad.
- La Web Audio API del navegador requiere una conversión de base64 a PCM16 y luego a Float32.