Comment créer un SVI avancé / un robot vocal

const express = require('express');
const { OpenAI } = require('openai');

const app = express();
app.use(express.json());

const openai = new OpenAI({ apiKey: 'YOUR_OPENAI_API_KEY' });

// 1. Handle the initial call
app.get('/webhooks/answer', (req, res) => {
  const ncco = [
    {
      action: 'talk',
      text: 'Hi, I am your AI assistant. How can I help you today?'
    },
    {
      action: 'input',
      eventUrl: [`${req.protocol}://${req.get('host')}/webhooks/asr`],
      type: ['speech'],
      speech: {
        language: 'en-us',
        endOnSilence: 1
      }
    }
  ];
  res.json(ncco);
});

// 2. Process the Speech-to-Text result and query OpenAI
app.post('/webhooks/asr', async (req, res) => {
  const speechResults = req.body.speech?.results;

  if (!speechResults || speechResults.length === 0) {
    return res.json([{ action: 'talk', text: 'I am sorry, I didn\'t catch that. Goodbye.' }]);
  }

  const userText = speechResults[0].text;
  console.log(`User said: ${userText}`);

  try {
    // Request a completion from OpenAI
    const completion = await openai.chat.completions.create({
      model: "gpt-4o",
      messages: [
        { role: "system", content: "You are a helpful assistant on a phone call. Keep answers concise." },
        { role: "user", content: userText }
      ],
    });

    const aiResponse = completion.choices[0].message.content;

    // Respond back to the user
    res.json([{ action: 'talk', text: aiResponse }]);
    
  } catch (error) {
    console.error("OpenAI Error:", error);
    res.json([{ action: 'talk', text: 'I encountered an error processing your request.' }]);
  }
});

// 3. Log call events
app.post('/webhooks/events', (req, res) => {
  console.log('Event:', req.body.status);
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Server running on port 3000'));

// 1. Add a Map to store conversation history by Call UUID
const sessions = new Map();

// Helper to generate a NCCO that "loops" back to ASR
const getConversationalNCCO = (text, host) => [
  { action: 'talk', text: text },
  {
    action: 'input',
    eventUrl: [`https://${host}/webhooks/asr`],
    type: ['speech'],
    speech: { language: 'en-us', endOnSilence: 1 }
  }
];

app.get('/webhooks/answer', (req, res) => {
  const uuid = req.query.uuid;
  // Initialize history for this specific caller
  sessions.set(uuid, [{ role: "system", content: "You are a helpful, concise assistant." }]);
  
  res.json(getConversationalNCCO('Hello! What is on your mind?', req.get('host')));
});

app.post('/webhooks/asr', async (req, res) => {
  const { uuid, speech } = req.body;
  const userText = speech?.results?.[0]?.text;

  if (!userText) {
    sessions.delete(uuid);
    return res.json([{ action: 'talk', text: 'Goodbye!' }]);
  }

  // Retrieve history and append the new question
  let history = sessions.get(uuid) || [];
  history.push({ role: "user", content: userText });

  const completion = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: history,
  });

  const aiResponse = completion.choices[0].message.content;
  history.push({ role: "assistant", content: aiResponse });
  sessions.set(uuid, history);

  // Return the AI response AND listen for the next question
  res.json(getConversationalNCCO(aiResponse, req.get('host')));
});

// Clean up memory when the call ends
app.post('/webhooks/events', (req, res) => {
  if (req.body.status === 'completed') sessions.delete(req.body.uuid);
  res.sendStatus(200);
});

// Define the transfer tool
const tools = [
  {
    type: "function",
    function: {
      name: "connect_to_human",
      description: "Call this when the user wants to speak to a real person or a human agent.",
      parameters: { type: "object", properties: {} } // No arguments needed
    }
  }
];

const HUMAN_AGENT_NUMBER = '15551234567'; // Replace with your phone number

app.post('/webhooks/asr', async (req, res) => {
  const { uuid, speech } = req.body;
  const userText = speech?.results?.[0]?.text;

  if (!userText) return res.json([{ action: 'talk', text: 'Goodbye.' }]);

  let history = sessions.get(uuid) || [];
  history.push({ role: "user", content: userText });

  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: history,
    tools: tools // Provide the tool to the LLM
  });

  const message = response.choices[0].message;

  // Check if the AI wants to transfer the call
  if (message.tool_calls && message.tool_calls[0].function.name === 'connect_to_human') {
    console.log(`Transferring call ${uuid} to human agent...`);
    
    // Clean up session since the AI is leaving the call
    sessions.delete(uuid);

    // Return the "connect" NCCO
    return res.json([
      { 
        action: 'talk', 
        text: 'Please hold while I connect you to a human representative.' 
      },
      {
        action: 'connect',
        from: 'YOUR_VONAGE_NUMBER', // Your linked Vonage number
        endpoint: [{ type: 'phone', number: HUMAN_AGENT_NUMBER }]
      }
    ]);
  }

  // Regular conversational flow
  const aiResponse = message.content;
  history.push({ role: "assistant", content: aiResponse });
  sessions.set(uuid, history);

  res.json(getConversationalNCCO(aiResponse, req.get('host')));
});