let ttsWebSocket;
let callSid;
let messageComplete = false;
let audioChunksReceived = 0;
function log(message) {
console.log(`[${new Date().toISOString()}] ${message}`);
}
function connectToTTSWebSocket() {
return new Promise((resolve, reject) => {
log('Attempting to connect to TTS WebSocket');
ttsWebSocket = new WebSocket(TTS_WEBSOCKET_URL, {
headers: { 'X-Api-Key': config.CARTESIA_API_KEY }
});
ttsWebSocket.on('open', () => {
log('Connected to TTS WebSocket');
resolve(ttsWebSocket);
});
ttsWebSocket.on('error', (error) => {
log(`TTS WebSocket error: ${error.message}`);
reject(error);
});
ttsWebSocket.on('close', (code, reason) => {
log(`TTS WebSocket closed. Code: ${code}, Reason: ${reason}`);
reject(new Error('TTS WebSocket closed unexpectedly'));
});
});
}
function sendTTSMessage(message) {
const textMessage = {
'model_id': modelId,
'transcript': message,
'voice': voice,
'output_format': {
'container': 'raw',
'encoding': 'pcm_mulaw',
'sample_rate': 8000
},
// create a new context for each message since each is a complete transcript
'context_id': crypto.randomUUID()
};
log(`Sending message to TTS WebSocket: ${message}`);
ttsWebSocket.send(JSON.stringify(textMessage));
}
function testTTSWebSocket() {
return new Promise((resolve, reject) => {
const testMessage = 'This is a test message';
let receivedAudio = false;
sendTTSMessage(testMessage);
const timeout = setTimeout(() => {
if (!receivedAudio) {
reject(new Error('Timeout: No audio received from TTS WebSocket'));
}
}, 10000); // 10 second timeout
ttsWebSocket.on('message', (audioChunk) => {
if (!receivedAudio) {
log(audioChunk);
log('Received audio chunk from TTS for test message');
receivedAudio = true;
clearTimeout(timeout);
resolve();
}
});
});
}
async function startCall(twilioWebsocketUrl) {
try {
log(`Initiating call with WebSocket URL: ${twilioWebsocketUrl}`);
const call = await client.calls.create({
twiml: `<Response><Connect><Stream url="${twilioWebsocketUrl}"/></Connect></Response>`,
to: outbound, // Replace with the phone number you want to call
from: inbound // Replace with your Twilio phone number
});
callSid = call.sid;
log(`Call initiated. SID: ${callSid}`);
} catch (error) {
log(`Error initiating call: ${error.message}`);
throw error;
}
}
async function hangupCall() {
try {
log(`Attempting to hang up call: ${callSid}`);
await client.calls(callSid).update({status: 'completed'});
log('Call hung up successfully');
} catch (error) {
log(`Error hanging up call: ${error.message}`);
}
}
function setupTwilioWebSocket() {
return new Promise((resolve, reject) => {
const server = http.createServer((req, res) => {
log(`Received HTTP request: ${req.method} ${req.url}`);
res.writeHead(200);
res.end('WebSocket server is running');
});
const wss = new WebSocket.Server({ server });
log('WebSocket server created');
wss.on('connection', (twilioWs, request) => {
log(`Twilio WebSocket connection attempt from ${request.socket.remoteAddress}`);
let streamSid = null;
twilioWs.on('message', (message) => {
try {
const msg = JSON.parse(message);
log(`Received message from Twilio: ${JSON.stringify(msg)}`);
if (msg.event === 'start') {
log('Media stream started');
streamSid = msg.start.streamSid;
log(`Stream SID: ${streamSid}`);
sendTTSMessage(partialResponse);
} else if (msg.event === 'media' && !messageComplete) {
log('Received media event');
} else if (msg.event === 'stop') {
log('Media stream stopped');
hangupCall();
}
} catch (error) {
log(`Error processing Twilio message: ${error.message}`);
}
});
twilioWs.on('close', (code, reason) => {
log(`Twilio WebSocket disconnected. Code: ${code}, Reason: ${reason}`);
});
twilioWs.on('error', (error) => {
log(`Twilio WebSocket error: ${error.message}`);
});
// Handle incoming audio chunks from TTS WebSocket
ttsWebSocket.on('message', (audioChunk) => {
log('Received audio chunk from TTS');
try {
if (streamSid) {
twilioWs.send(JSON.stringify({
event: 'media',
streamSid: streamSid,
media: {
payload: JSON.parse(audioChunk)['data']
}
}));
audioChunksReceived++;
log(`Audio chunks received: ${audioChunksReceived}`);
if (audioChunksReceived >= 50) {
messageComplete = true;
log('Message complete, preparing to hang up');
setTimeout(hangupCall, 2000);
}
} else {
log('Warning: Received audio chunk but streamSid is not set');
}
} catch (error) {
log(`Error sending audio chunk to Twilio: ${error.message}`);
}
});
log('Twilio WebSocket connected and handlers set up');
});
wss.on('error', (error) => {
log(`WebSocket server error: ${error.message}`);
});
server.listen(0, () => {
const port = server.address().port;
log(`Twilio WebSocket server is running on port ${port}`);
resolve(port);
});
server.on('error', (error) => {
log(`HTTP server error: ${error.message}`);
reject(error);
});
});
}
async function setupNgrokTunnel(port) {
try {
const listener = await ngrok.forward({
addr: port,
authtoken: config.NGROK_AUTHTOKEN,
});
const wssUrl = listener.url().replace('https://', 'wss://');
log(`ngrok tunnel established: ${wssUrl}`);
return wssUrl;
} catch (error) {
log(`Error setting up ngrok tunnel: ${error.message}`);
throw error;
}
}
async function main() {
try {
log('Starting application');
await connectToTTSWebSocket();
log('TTS WebSocket connected successfully');
await testTTSWebSocket();
log('TTS WebSocket test passed successfully');
const twilioWebsocketPort = await setupTwilioWebSocket();
log(`Twilio WebSocket server set up on port ${twilioWebsocketPort}`);
const twilioWebsocketUrl = await setupNgrokTunnel(twilioWebsocketPort);
await startCall(twilioWebsocketUrl);
} catch (error) {
log(`Error in main function: ${error.message}`);
}
}
// Run the script
main();
