Ir al contenido principal
Español— Elegir un idioma
Menú

Recibir y reproducir el audio de la respuesta

Lección 11 de 16 Actualizado el 30 de julio de 2026 Desarrollador
En esta página
  1. Reproducción en streaming
  2. Arquitectura del reproductor de audio
  3. Conexión con los eventos de WebSocket
  4. Gestión de interrupciones
  5. Reproductor de audio en Python
  6. Mostrar la transcripción simultáneamente
  7. Puntos clave

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:

  1. Detectar la interrupción: el evento speech_started llega mientras se reproduce el audio.
  2. Detener la reproducción: vaciar la cola de audio y cortar el sonido.
  3. Cancelar la respuesta: enviar response.cancel para que el servidor deje de generar contenido.
  4. 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.