# Node.js VoiceBot Server Handover

Questo documento descrive come configurare il server Node.js per gestire gli stream audio di Twilio e interfacciarsi con il backend Laravel esistente.

## Obiettivo
Il server Node.js funge da gateway real-time. Riceve pacchetti audio binari da Twilio tramite WebSocket, li accumula e, al termine della frase dell'utente, invia l'intero blocco audio a Laravel per l'elaborazione (Trascrizione + AI + TTS). Infine, riceve la risposta audio da Laravel e la invia a Twilio.

## Integrazione Backend Laravel

Il backend Laravel espone un'API dedicata e protetta.

- **Endpoint**: `POST /api/voicebot/process`
- **Autenticazione**: Header `X-VoiceBot-Key`
  - La chiave deve corrispondere a `VOICEBOT_API_KEY` definita nel file `.env` di Laravel.
- **Formato Richiesta (JSON)**:
  ```json
  {
    "callSid": "CA...",
    "phone": "+39123456789",
    "recipient": "+39987654321",
    "profile_id": 123,
    "audio": "BASE64_ENCODED_AUDIO_DATA"
  }
  ```
  *Nota: Laravel si aspetta dati audio che Whisper può processare (es: MP3, WAV, etc.). Se Twilio invia mu-law (8000Hz), potrebbe essere necessaria una conversione sul server Node o un invio raw se Whisper la supporta correttamente tramite wrapper.*

- **Formato Risposta (JSON)**:
  ```json
  {
    "success": true,
    "transcript": "Testo trascritto dall'utente",
    "ai_response": "Risposta generata dall'AI",
    "audio_response": "BASE64_ENCODED_MP3_FROM_TTS"
  }
  ```

## Esempio Concettuale Node.js

Utilizzare i pacchetti `ws` per WebSocket e `axios` per le chiamate HTTP.

```javascript
const WebSocket = require('ws');
const axios = require('axios');

const LARAVEL_API_URL = 'https://tuo-dominio.it/api/voicebot/process';
const VOICEBOT_API_KEY = 'la-tua-chiave-segreta'; // Caricare da .env

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
    let audioBuffer = Buffer.alloc(0);
    let callSid = null;
    let streamSid = null;
    let phone = null;
    let recipient = null;
    let profileId = null;

    ws.on('message', async (message) => {
        const data = JSON.parse(message);

        switch (data.event) {
            case 'start':
                callSid = data.start.callSid;
                streamSid = data.start.streamSid;
                // I parametri From, To e profile_id passati da Laravel sono in customParameters
                phone = data.start.customParameters.phone;
                recipient = data.start.customParameters.recipient;
                profileId = data.start.customParameters.profile_id;
                console.log(`Chiamata iniziata: ${callSid} da ${phone} a ${recipient} (Profile: ${profileId})`);
                break;

            case 'media':
                // Twilio invia audio in base64 (payload mu-law)
                const chunk = Buffer.from(data.media.payload, 'base64');
                audioBuffer = Buffer.concat([audioBuffer, chunk]);
                break;

            case 'stop':
                console.log(`Chiamata terminata: ${callSid}. Invio a Laravel...`);
                
                try {
                    const response = await axios.post(LARAVEL_API_URL, {
                        callSid: callSid,
                        phone: phone,
                        recipient: recipient,
                        profile_id: profileId,
                        audio: audioBuffer.toString('base64')
                    }, {
                        headers: { 'X-VoiceBot-Key': VOICEBOT_API_KEY }
                    });

                    if (response.data.success) {
                        // Invia l'audio della risposta a Twilio
                        // Nota: Twilio richiede pacchetti 'media' con payload base64
                        ws.send(JSON.stringify({
                            event: 'media',
                            streamSid: streamSid,
                            media: {
                                payload: response.data.audio_response
                            }
                        }));
                    }
                } catch (error) {
                    console.error('Errore durante l\'invio a Laravel:', error.message);
                }
                break;
        }
    });
});
```

## Requisiti lato Server (Plesk)
1. **Node.js**: Abilitare l'estensione Node.js nel dominio/sottodominio scelto (es. `ws.ai4dealers.it`).
2. **Reverse Proxy**: Assicurarsi che Nginx sia configurato per supportare WebSocket (header `Upgrade` e `Connection`).
3. **SSL**: Il WebSocket deve viaggiare su `wss://` se il sito Laravel è in `https://`.

## Configurazione Twilio
Il webhook di Twilio per la chiamata deve rispondere con un TwiML che include il tag `<Stream>`:
```xml
<Response>
    <Connect>
        <Stream url="wss://ws.tuodominio.it" />
    </Connect>
</Response>
```