Schéma (MVP sans Daily)

2) Bridge Node (WebSocket, ASR→LLM→TTS avec OpenAI)

Ce bridge reçoit des chunks Opus (webm), les décode en PCM, pousse en ASR, appelle le LLM (avec tools si besoin), puis génère du TTS et renvoie des blocs WAV au navigateur.

// server.ts (Node 18+, TypeScript conseillé)
import http from "http";
import { WebSocketServer } from "ws";
import express from "express";
import { tmpdir } from "os";
import { writeFileSync, unlinkSync } from "fs";
import { randomUUID } from "crypto";
import { spawn } from "child_process"; // pour décoder opus -> wav via ffmpeg
import OpenAI from "openai";

const app = express();
const server = http.createServer(app);
const wss = new WebSocketServer({ server, path: "/ws" });
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY! });

type SessionState = {
  opusBuffers: Buffer[];
  ended: boolean;
};

wss.on("connection", (ws) => {
  const state: SessionState = { opusBuffers: [], ended: false };

  ws.on("message", async (data) => {
    // Marker de fin d’énoncé
    if (typeof data === "string") {
      try {
        const msg = JSON.parse(data);
        if (msg.type === "end_of_utterance") {
          state.ended = true;
          // Traiter l’énoncé maintenant
          await handleUtterance(ws, state);
          // reset pour écoute suivante
          state.opusBuffers = [];
          state.ended = false;
        }
      } catch {}
      return;
    }
    // Binaire = chunk opus/webm
    state.opusBuffers.push(Buffer.from(data as ArrayBuffer));
  });

  ws.on("close", () => {});
});

async function handleUtterance(ws: any, state: SessionState) {
  if (!state.opusBuffers.length) return;

  // 1) Sauver l’opus temporaire
  const opusFile = `${tmpdir()}/${randomUUID()}.webm`;
  writeFileSync(opusFile, Buffer.concat(state.opusBuffers));

  // 2) Convertir en wav PCM mono 16k via ffmpeg
  const wavFile = `${tmpdir()}/${randomUUID()}.wav`;
  await ffmpegConvert(opusFile, wavFile);

  // 3) ASR (Whisper)
  const transcript = await transcribeWav(wavFile);

  // 4) LLM (avec tools si vous devez “appeler des services extérieurs”)
  const answer = await callLLM(transcript.text);

  // 5) TTS → wav (OpenAI TTS)
  const wavBuffer = await synthesizeTTS(answer);

  // 6) Renvoi au client (il jouera le blob audio)
  ws.send(wavBuffer);

  // Cleanup
  try { unlinkSync(opusFile); unlinkSync(wavFile); } catch {}
}

function ffmpegConvert(inFile: string, outFile: string) {
  return new Promise<void>((resolve, reject) => {
    const ff = spawn("ffmpeg", ["-y", "-i", inFile, "-ac", "1", "-ar", "16000", "-f", "wav", outFile]);
    ff.on("error", reject);
    ff.on("close", (code) => code === 0 ? resolve() : reject(new Error("ffmpeg failed")));
  });
}

async function transcribeWav(wavPath: string) {
  // Whisper file transcription (non-streaming pour MVP)
  const resp = await openai.audio.transcriptions.create({
    file: (await import("fs")).createReadStream(wavPath),
    model: "whisper-1", // remplacez par le modèle ASR actuel de votre compte
    // language: "fr"
  });
  return resp; // { text: "..." }
}

async function callLLM(userText: string): Promise<string> {
  const sys = "Vous êtes un conseiller personnel utile, concis, en français.";
  const chat = await openai.chat.completions.create({
    model: "gpt-4o-mini", // ou autre modèle dispo
    messages: [
      { role: "system", content: sys },
      { role: "user", content: userText }
    ],
    temperature: 0.2,
  });
  return chat.choices[0]?.message?.content ?? "Je n’ai pas compris.";
}

async function synthesizeTTS(text: string): Promise<Buffer> {
  // TTS (voix FR) — adaptez au moteur TTS disponible sur votre compte
  const speech = await openai.audio.speech.create({
    model: "gpt-4o-mini-tts", // exemple : remplacez par le modèle TTS actif
    voice: "alloy", // ou voix FR si disponible
    format: "wav",
    input: text,
  });
  // L’SDK renvoie ArrayBuffer/stream selon version — normalisez en Buffer:
  const arrayBuffer = await speech.arrayBuffer();
  return Buffer.from(arrayBuffer);
}

const PORT = process.env.PORT || 8080;
server.listen(PORT, () => console.log(`Bridge listening on :${PORT}`));

Notes importantes

• Latence : chunks 250 ms côté client, ffmpeg pour convertir Opus→PCM 16 kHz, ASR non-streaming (MVP). Pour du quasi temps réel, passez à l’ASR streaming (OpenAI Realtime) et au TTS streaming (envoyez de petits bouts d’audio au fur et à mesure).
• Barge-in : pendant que le TTS joue, continuez à écouter le micro et coupez la synthèse si l’utilisateur reparle.
• Qualité audio : micro mono 16 kHz suffit pour l’ASR. Si vous ciblez une meilleure prosodie TTS, gardez 24 kHz côté synthèse.