Custom TTS integration

1
{
2
  "voice": {
3
    "provider": "custom-voice",
4
    "server": {
5
      "url": "https://your-tts-api.com/synthesize",
6
      "secret": "your-secret-token-here",
7
      "timeoutSeconds": 30
8
    }
9
  }
10
}

1
{
2
  "voice": {
3
    "provider": "custom-voice",
4
    "server": {
5
      "url": "https://your-tts-api.com/synthesize",
6
      "secret": "your-secret-token",
7
      "headers": {
8
        "X-API-Version": "v1",
9
        "X-Client-ID": "vapi-integration"
10
      }
11
    }
12
  }
13
}

1
{
2
  "name": "Custom Voice Assistant",
3
  "voice": {
4
    "provider": "custom-voice",
5
    "server": {
6
      "url": "https://your-tts-endpoint.com/api/synthesize",
7
      "secret": "your-webhook-secret",
8
      "timeoutSeconds": 45,
9
      "headers": {
10
        "Content-Type": "application/json",
11
        "X-API-Version": "v1"
12
      }
13
    },
14
    "fallbackPlan": {
15
      "voices": [
16
        {
17
          "provider": "eleven-labs",
18
          "voiceId": "21m00Tcm4TlvDq8ikWAM"
19
        }
20
      ]
21
    }
22
  }
23
}

1
const express = require('express');
2
const crypto = require('crypto');
3
4
const app = express();
5
app.use(express.json({ limit: '50mb' }));
6
7
// Main TTS endpoint
8
app.post('/api/synthesize', async (req, res) => {
9
const requestId = crypto.randomUUID();
10
const startTime = Date.now();
11
12
// Set up timeout protection
13
const timeout = setTimeout(() => {
14
if (!res.headersSent) {
15
res.status(408).json({ error: 'Request timeout' });
16
}
17
}, 30000);
18
19
try {
20
console.log(`TTS request started: ${requestId}`);
21
22
    // Extract and validate the request
23
    const { message } = req.body;
24
    if (!message) {
25
      clearTimeout(timeout);
26
      return res.status(400).json({ error: 'Missing message object' });
27
    }
28
29
    const { type, text, sampleRate } = message;
30
31
    // Validate message type
32
    if (type !== 'voice-request') {
33
      clearTimeout(timeout);
34
      return res.status(400).json({ error: 'Invalid message type' });
35
    }
36
37
    // Validate text content
38
    if (!text || typeof text !== 'string' || text.trim().length === 0) {
39
      clearTimeout(timeout);
40
      return res.status(400).json({ error: 'Invalid or missing text' });
41
    }
42
43
    // Validate sample rate
44
    const validSampleRates = [8000, 16000, 22050, 24000, 44100];
45
    if (!validSampleRates.includes(sampleRate)) {
46
      clearTimeout(timeout);
47
      return res.status(400).json({
48
        error: 'Unsupported sample rate',
49
        supportedRates: validSampleRates,
50
      });
51
    }
52
53
    console.log(
54
      `Synthesizing: ${requestId}, length=${text.length}, rate=${sampleRate}Hz`
55
    );
56
57
    // Generate the audio (replace with your TTS implementation)
58
    const audioBuffer = await synthesizeAudio(text, sampleRate);
59
60
    if (!audioBuffer || audioBuffer.length === 0) {
61
      throw new Error('TTS synthesis produced no audio');
62
    }
63
64
    clearTimeout(timeout);
65
66
    // Return raw PCM audio to VAPI
67
    res.setHeader('Content-Type', 'application/octet-stream');
68
    res.setHeader('Content-Length', audioBuffer.length);
69
    res.write(audioBuffer);
70
    res.end();
71
72
    const duration = Date.now() - startTime;
73
    console.log(
74
      `TTS completed: ${requestId}, ${duration}ms, ${audioBuffer.length} bytes`
75
    );
76
77
} catch (error) {
78
clearTimeout(timeout);
79
const duration = Date.now() - startTime;
80
console.error(`TTS failed: ${requestId}, ${duration}ms, ${error.message}`);
81
82
    if (!res.headersSent) {
83
      res.status(500).json({ error: 'TTS synthesis failed', requestId });
84
    }
85
86
}
87
});
88
89
// Replace with your actual TTS implementation
90
async function synthesizeAudio(text, sampleRate) {
91
// Example: Call your TTS API here
92
// const audioBuffer = await yourTTSProvider.synthesize(text, sampleRate);
93
94
// Demo implementation (replace with real TTS)
95
await new Promise(resolve => setTimeout(resolve, 100));
96
97
const duration = Math.min(text.length _ 0.1, 10); // Max 10 seconds
98
const samples = Math.floor(duration _ sampleRate);
99
const buffer = Buffer.alloc(samples \* 2); // 16-bit = 2 bytes per sample
100
101
for (let i = 0; i < samples; i++) {
102
const value = Math.sin((2 _ Math.PI _ 440 _ i) / sampleRate) _ 16000;
103
buffer.writeInt16LE(Math.round(value), i \* 2);
104
}
105
106
return buffer;
107
}
108
109
// Error handling middleware
110
app.use((error, req, res, next) => {
111
console.error('Unhandled error:', error.message);
112
res.status(500).json({ error: 'Internal server error' });
113
});
114
115
const PORT = process.env.PORT || 3000;
116
app.listen(PORT, () => {
117
console.log(`TTS server listening on port ${PORT}`);
118
});
119
120
module.exports = app;

1
function preprocessText(text) {
2
  // Handle SSML tags if your TTS supports them
3
  if (text.includes('<speak>')) {
4
    return parseSSML(text);
5
  }
6
7
  // Clean up problematic characters
8
  return text
9
    .replace(/[^\w\s\.,!?-]/g, '') // Remove special characters
10
    .replace(/\s+/g, ' ') // Normalize whitespace
11
    .trim();
12
}
13
14
function validateText(text) {
15
  if (!text || text.trim().length === 0) {
16
    throw new Error('Empty text provided');
17
  }
18
19
  if (!/[a-zA-Z]/.test(text)) {
20
    throw new Error('No readable text found');
21
  }
22
23
  return text.trim();
24
}

1
{
2
  "message": {
3
    "type": "voice-request",
4
    "text": "Hello, world! How can I help you today?",
5
    "sampleRate": 24000,
6
    "timestamp": 1677123456789,
7
    "call": {
8
      "id": "call-123",
9
      "orgId": "org-456"
10
    },
11
    "assistant": {
12
      "id": "assistant-789",
13
      "name": "Customer Service Bot"
14
    },
15
    "customer": {
16
      "number": "+1234567890"
17
    }
18
  }
19
}

1
HTTP/1.1 200 OK
2
Content-Type: application/octet-stream
3
Transfer-Encoding: chunked
4
5
[Raw PCM audio bytes]

1
async function testTTSWithVAPICall() {
2
  const vapiApiKey = 'your-vapi-api-key';
3
  const assistantId = 'your-assistant-id'; // Assistant with custom TTS
4
5
  const callData = {
6
    assistant: { id: assistantId },
7
    phoneNumberId: 'your-phone-number-id',
8
    customer: { number: '+1234567890' }, // Your test number
9
  };
10
11
  try {
12
    const response = await fetch('https://api.vapi.ai/call', {
13
      method: 'POST',
14
      headers: {
15
        Authorization: `Bearer ${vapiApiKey}`,
16
        'Content-Type': 'application/json',
17
      },
18
      body: JSON.stringify(callData),
19
    });
20
21
    const call = await response.json();
22
    console.log('Test call created:', call.id);
23
    return call;
24
  } catch (error) {
25
    console.error('Failed to create test call:', error);
26
  }
27
}

1
app.use('/api/synthesize', (req, res, next) => {
2
  console.log('=== Incoming TTS Request ===');
3
  console.log('Headers:', req.headers);
4
  console.log('Body:', JSON.stringify(req.body, null, 2));
5
  console.log('==============================');
6
  next();
7
});

1
async function quickEndpointTest() {
2
  const testPayload = {
3
    message: {
4
      type: 'voice-request',
5
      text: 'Hello, this is a test of the custom TTS system.',
6
      sampleRate: 24000,
7
      timestamp: Date.now(),
8
    },
9
  };
10
11
try {
12
const response = await fetch('http://localhost:3000/api/synthesize', {
13
method: 'POST',
14
headers: {
15
'Content-Type': 'application/json',
16
'X-VAPI-SECRET': 'your-test-secret',
17
},
18
body: JSON.stringify(testPayload),
19
});
20
21
    if (response.ok) {
22
      const audioBuffer = await response.buffer();
23
      console.log(`Audio generated: ${audioBuffer.length} bytes`);
24
      require('fs').writeFileSync('test-output.pcm', audioBuffer);
25
    } else {
26
      console.error('Test failed:', await response.text());
27
    }
28
29
} catch (error) {
30
console.error('Test error:', error);
31
}
32
}