Call queue management with Twilio

1
const express = require('express');
2
const twilio = require('twilio');
3
const axios = require('axios');
4
require('dotenv').config();
5
6
const app = express();
7
const twilioClient = twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);
8
9
// Concurrency and queue tracking
10
let activeCalls = 0;
11
let callsInQueue = 0;
12
const MAX_CONCURRENCY = parseInt(process.env.MAX_CONCURRENCY) || 5;
13
14
// Middleware
15
app.use(express.json());
16
app.use(express.urlencoded({ extended: true }));
17
18
// Incoming call handler - adds calls to queue
19
app.post('/incoming', (req, res) => {
20
  try {
21
    const twiml = `<?xml version="1.0" encoding="UTF-8"?>
22
      <Response>
23
        <Enqueue>customer-support</Enqueue>
24
      </Response>`;
25
    
26
    res.set('Content-Type', 'application/xml');
27
    res.send(twiml);
28
    
29
    // Increment queue counter
30
    callsInQueue++;
31
    console.log(`Call ${req.body.CallSid} added to queue. Calls in queue: ${callsInQueue}`);
32
  } catch (error) {
33
    console.error('Error handling incoming call:', error);
34
    res.status(500).send('Error processing call');
35
  }
36
});
37
38
// Queue processing function
39
async function processQueue() {
40
  try {
41
    // Check if we have capacity for more calls
42
    if (activeCalls >= MAX_CONCURRENCY) {
43
      return;
44
    }
45
46
    // Check if there are calls in queue
47
    if (callsInQueue === 0) {
48
      return;
49
    }
50
51
    // Get next call from queue
52
    const members = await twilioClient.queues(process.env.TWILIO_QUEUE_SID)
53
      .members
54
      .list({ limit: 1 });
55
56
    if (members.length === 0) {
57
      // No calls in queue - sync our counter
58
      callsInQueue = 0;
59
      return;
60
    }
61
62
    const member = members[0];
63
    console.log(`Processing queued call: ${member.callSid}`);
64
65
    // Get Vapi TwiML for this call
66
    const twiml = await initiateVapiCall(member.callSid, member.phoneNumber);
67
    
68
    if (twiml) {
69
      // Update call with Vapi TwiML
70
      await twilioClient.calls(member.callSid).update({ twiml });
71
      
72
      // Increment active call counter and decrement queue counter
73
      activeCalls++;
74
      callsInQueue--;
75
      console.log(`Call connected to Vapi. Active calls: ${activeCalls}/${MAX_CONCURRENCY}, Queue: ${callsInQueue}`);
76
    } else {
77
      console.error(`Failed to get TwiML for call ${member.callSid}`);
78
    }
79
  } catch (error) {
80
    console.error('Error processing queue:', error);
81
  }
82
}
83
84
// Generate Vapi TwiML for a call
85
async function initiateVapiCall(callSid, customerNumber) {
86
  const payload = {
87
    phoneNumberId: process.env.VAPI_PHONE_NUMBER_ID,
88
    phoneCallProviderBypassEnabled: true,
89
    customer: { number: customerNumber },
90
    assistantId: process.env.VAPI_ASSISTANT_ID,
91
  };
92
93
  const headers = {
94
    'Authorization': `Bearer ${process.env.VAPI_API_KEY}`,
95
    'Content-Type': 'application/json',
96
  };
97
98
  try {
99
    const response = await axios.post('https://api.vapi.ai/call', payload, { headers });
100
    
101
    if (response.data && response.data.phoneCallProviderDetails) {
102
      return response.data.phoneCallProviderDetails.twiml;
103
    } else {
104
      throw new Error('Invalid response structure from Vapi');
105
    }
106
  } catch (error) {
107
    console.error(`Error initiating Vapi call for ${callSid}:`, error.message);
108
    return null;
109
  }
110
}
111
112
// Webhook for call completion (decrements active calls)
113
app.post('/call-ended', (req, res) => {
114
  try {
115
    // Handle Vapi end-of-call-report webhook
116
    const message = req.body.message;
117
    
118
    if (message && message.type === 'end-of-call-report') {
119
      const callId = message.call?.id;
120
      
121
      if (activeCalls > 0) {
122
        activeCalls--;
123
        console.log(`Vapi call ${callId} ended. Active calls: ${activeCalls}/${MAX_CONCURRENCY}`);
124
        // Note: Queue processing happens automatically every 1 second
125
      }
126
    }
127
    
128
    res.status(200).send('OK');
129
  } catch (error) {
130
    console.error('Error handling Vapi webhook:', error);
131
    res.status(500).send('Error');
132
  }
133
});
134
135
// Manual queue processing endpoint (for testing/monitoring)
136
app.post('/process-queue', async (req, res) => {
137
  try {
138
    await processQueue();
139
    res.json({ 
140
      message: 'Queue processing triggered',
141
      activeCalls,
142
      callsInQueue,
143
      maxConcurrency: MAX_CONCURRENCY 
144
    });
145
  } catch (error) {
146
    console.error('Error in manual queue processing:', error);
147
    res.status(500).json({ error: 'Failed to process queue' });
148
  }
149
});
150
151
// Health check endpoint
152
app.get('/health', (req, res) => {
153
  res.json({
154
    status: 'healthy',
155
    activeCalls,
156
    callsInQueue,
157
    maxConcurrency: MAX_CONCURRENCY,
158
    availableCapacity: MAX_CONCURRENCY - activeCalls
159
  });
160
});
161
162
// Start server
163
const PORT = process.env.PORT || 3000;
164
app.listen(PORT, () => {
165
  console.log(`Queue management server running on port ${PORT}`);
166
  console.log(`Max concurrency: ${MAX_CONCURRENCY}`);
167
  
168
  // Start automatic queue processing every 1 second
169
  startQueueProcessor();
170
});
171
172
// Automatic queue processing with 1-second interval
173
function startQueueProcessor() {
174
  setInterval(async () => {
175
    try {
176
      // Only process queue if there are calls waiting
177
      if (callsInQueue > 0) {
178
        await processQueue();
179
      }
180
    } catch (error) {
181
      console.error('Error in automatic queue processing:', error);
182
    }
183
  }, 1000); // Check queue every 1 second
184
  
185
  console.log('Automatic queue processor started (1-second interval)');
186
}
187
188
module.exports = app;

1
const assistantConfig = {
2
  name: "Queue Management Assistant",
3
  // ... other assistant configuration
4
  
5
  // Configure server URL for webhooks
6
  server: {
7
    url: "https://your-server.com",
8
    timeoutSeconds: 20
9
  },
10
  
11
  // Configure which messages to send to your server
12
  serverMessages: ["end-of-call-report", "status-update"]
13
};

1
{
2
  "message": {
3
    "type": "end-of-call-report",
4
    "call": {
5
      "id": "73a6da0f-c455-4bb6-bf4a-5f0634871430",
6
      "status": "ended",
7
      "endedReason": "assistant-ended-call"
8
    }
9
  }
10
}