// Assistant config for eCommerce lead qualification
const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    temperature: 0.7,
    systemPrompt: `You are a sales qualification agent for an eCommerce platform. Your goal: qualify leads in under 3 minutes.

REQUIRED DATA POINTS:
- Monthly order volume (disqualify if <100 orders/month)
- Current platform (Shopify/WooCommerce/Custom)
- Pain points (checkout abandonment, inventory sync, shipping delays)
- Decision timeline (immediate/30 days/90+ days)
- Budget authority (yes/no/needs approval)

DISQUALIFICATION TRIGGERS:
- <100 orders/month → politely end call
- No budget authority + 90+ day timeline → schedule follow-up

Extract data conversationally. Don't interrogate. If they mention "our Shopify store crashes during sales", probe: "How often? What's your peak traffic?"`
  },
  voice: {
    provider: "11labs",
    voiceId: "21m00Tcm4TlvDq8ikWAM", // Professional female voice
    stability: 0.6,
    similarityBoost: 0.8
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en-US",
    keywords: ["Shopify", "WooCommerce", "BigCommerce", "checkout", "inventory"]
  },
  firstMessage: "Hi, this is Sarah from [YourCompany]. I saw you requested info about our eCommerce automation platform. Do you have 2 minutes to see if we're a fit?",
  endCallFunctionEnabled: true,
  recordingEnabled: true,
  serverUrl: process.env.WEBHOOK_URL,
  serverUrlSecret: process.env.WEBHOOK_SECRET
};

// Webhook handler for live lead scoring
app.post('/webhook/vapi', async (req, res) => {
  const { message } = req.body;
  
  if (message.type === 'transcript') {
    const transcript = message.transcript.toLowerCase();
    let score = 0;
    
    // Real-time scoring logic
    if (transcript.includes('100') || transcript.includes('thousand orders')) score += 30;
    if (transcript.includes('shopify') || transcript.includes('woocommerce')) score += 20;
    if (transcript.includes('checkout') && transcript.includes('abandon')) score += 25;
    if (transcript.includes('this week') || transcript.includes('asap')) score += 25;
    
    // Disqualification check
    if (transcript.includes('just browsing') || transcript.includes('no budget')) {
      await fetch(`${process.env.VAPI_API_URL}/call/${message.callId}/end`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${process.env.VAPI_API_KEY}`,
          'Content-Type': 'application/json'
        }
      });
    }
    
    // Update CRM in real-time (not after call ends)
    if (score >= 70) {
      await updateCRM({ leadId: message.callId, status: 'hot', score });
    }
  }
  
  res.sendStatus(200);
});

graph LR
    Mic[Microphone Input]
    ABuffer[Audio Buffering]
    VAD[Voice Activity Detection]
    STT[Speech-to-Text Conversion]
    NLU[Intent Analysis]
    API[External API Integration]
    LLM[Response Generation]
    TTS[Text-to-Speech Synthesis]
    Speaker[Speaker Output]
    Error[Error Handling]

    Mic --> ABuffer
    ABuffer --> VAD
    VAD -->|Voice Detected| STT
    VAD -->|Silence| Error
    STT -->|Text Output| NLU
    STT -->|Error| Error
    NLU -->|Intent Identified| API
    NLU -->|No Intent| Error
    API -->|Data Retrieved| LLM
    API -->|API Error| Error
    LLM --> TTS
    TTS --> Speaker
    Error -->|Log & Retry| Mic

// Test webhook handler locally
const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

app.post('/webhook/vapi', (req, res) => {
  // Validate webhook signature
  const signature = req.headers['x-vapi-signature'];
  const payload = JSON.stringify(req.body);
  const expectedSig = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSig) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  // Log event for debugging
  console.log('Event received:', req.body.message.type);
  console.log('Transcript:', req.body.message.transcript);
  console.log('Lead score:', req.body.message.score);

  res.status(200).json({ received: true });
});

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

# Test transcript-update event
curl -X POST https://your-ngrok-url.ngrok.io/webhook/vapi \
  -H "Content-Type: application/json" \
  -H "x-vapi-signature: test_signature" \
  -d '{
    "message": {
      "type": "transcript",
      "transcript": "I need 500 units by Friday",
      "score": 85
    }
  }'

// Barge-in handler with buffer flush
let isProcessing = false;
let audioBuffer = [];

app.post('/webhook/vapi', async (req, res) => {
  const payload = req.body;
  
  if (payload.message?.type === 'transcript' && payload.message.transcriptType === 'partial') {
    // Customer started speaking - cancel TTS immediately
    if (isProcessing) {
      audioBuffer = []; // Flush buffer to prevent old audio
      isProcessing = false;
    }
    
    const transcript = payload.message.transcript;
    
    // Detect interruption intent
    if (transcript.length > 10 && !isProcessing) {
      isProcessing = true;
      
      // Score lead based on interruption context
      const score = await scoreLeadIntent(transcript);
      
      // Update assistant context with new priority
      await fetch('https://api.vapi.ai/assistant/' + payload.call.assistantId, {
        method: 'PATCH',
        headers: {
          'Authorization': 'Bearer ' + process.env.VAPI_API_KEY,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          model: {
            messages: [{
              role: 'system',
              content: `Customer interrupted. Priority: ${score > 70 ? 'high-intent' : 'nurture'}. Address: "${transcript}"`
            }]
          }
        })
      });
      
      isProcessing = false;
    }
  }
  
  res.status(200).send();
});

// WRONG: Scores on every partial transcript
app.post('/webhook/vapi', (req, res) => {
  const { transcript } = req.body;
  // This fires 8x per sentence = wasted API calls
  const score = await scoreLeadQuality(transcript);
});

// CORRECT: Guard against concurrent scoring
let isProcessing = false;
app.post('/webhook/vapi', async (req, res) => {
  const { transcript, status } = req.body;
  
  // Only score on final transcript
  if (status !== 'completed' || isProcessing) {
    return res.status(200).send('OK');
  }
  
  isProcessing = true;
  try {
    const score = await scoreLeadQuality(transcript);
    await updateCRM(score);
  } finally {
    isProcessing = false;
  }
  
  res.status(200).send('OK');
});

const crypto = require('crypto');

app.post('/webhook/vapi', (req, res) => {
  const signature = req.headers['x-vapi-signature'];
  const payload = JSON.stringify(req.body);
  
  const expectedSig = crypto
    .createHmac('sha256', process.env.VAPI_WEBHOOK_SECRET)
    .update(payload)
    .digest('hex');
  
  if (signature !== expectedSig) {
    return res.status(401).send('Invalid signature');
  }
  
  // Process real-time lead scoring voice data
  const { transcript, score } = req.body;
});

// server.js - Complete Voice AI Lead Qualification Server
const express = require('express');
const crypto = require('crypto');
const app = express();

app.use(express.json());

// Session state management with cleanup
const sessions = new Map();
const SESSION_TTL = 3600000; // 1 hour

// Production-grade assistant configuration
const assistantConfig = {
  model: {
    provider: "openai",
    model: "gpt-4",
    temperature: 0.7,
    messages: [
      {
        role: "system",
        content: "You are a lead qualification specialist for an eCommerce store. Ask about: 1) Budget range 2) Timeline 3) Decision maker status 4) Current solution. Score each answer 0-25 points. Be conversational but efficient."
      }
    ]
  },
  voice: {
    provider: "11labs",
    voiceId: "21m00Tcm4TlvDq8ikWAM",
    stability: 0.5,
    similarityBoost: 0.75
  },
  transcriber: {
    provider: "deepgram",
    model: "nova-2",
    language: "en",
    keywords: ["budget", "timeline", "decision", "current solution"]
  },
  firstMessage: "Hi! I'm calling from [Your Store]. Do you have 2 minutes to discuss your needs?"
};

// Webhook signature validation (CRITICAL for production)
function validateWebhook(payload, signature) {
  const expectedSig = crypto
    .createHmac('sha256', process.env.VAPI_SERVER_SECRET)
    .update(JSON.stringify(payload))
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expectedSig)
  );
}

// Real-time lead scoring with race condition guard
let isProcessing = false;
async function scoreTranscript(transcript, sessionId) {
  if (isProcessing) return null;
  isProcessing = true;

  try {
    const session = sessions.get(sessionId) || { score: 0, transcript: [] };
    session.transcript.push(transcript);

    // Score based on qualification criteria
    let score = session.score;
    if (/budget|spend|\$\d+/.test(transcript.toLowerCase())) score += 25;
    if (/timeline|when|soon|month/.test(transcript.toLowerCase())) score += 25;
    if (/decision|approve|authority/.test(transcript.toLowerCase())) score += 25;
    if (/current|using|have/.test(transcript.toLowerCase())) score += 25;

    session.score = Math.min(score, 100);
    sessions.set(sessionId, session);

    // Auto-cleanup after TTL
    setTimeout(() => sessions.delete(sessionId), SESSION_TTL);

    return session.score;
  } finally {
    isProcessing = false;
  }
}

// Webhook handler for call events
app.post('/webhook/vapi', async (req, res) => {
  const signature = req.headers['x-vapi-signature'];
  const payload = req.body;

  if (!validateWebhook(payload, signature)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const { type, call } = payload;

  switch (type) {
    case 'transcript':
      const score = await scoreTranscript(
        payload.transcript.text,
        call.id
      );
      console.log(`Lead score: ${score}/100 for call ${call.id}`);
      
      // Trigger handoff if qualified (score >= 75)
      if (score >= 75) {
        return res.json({
          action: 'transfer',
          destination: process.env.SALES_PHONE_NUMBER
        });
      }
      break;

    case 'end-of-call-report':
      const session = sessions.get(call.id);
      console.log('Call ended:', {
        callId: call.id,
        finalScore: session?.score || 0,
        duration: call.duration,
        status: call.status
      });
      break;

    case 'function-call':
      // Handle custom function calls (e.g., CRM lookup)
      if (payload.functionCall.name === 'checkInventory') {
        return res.json({
          result: { inStock: true, quantity: 47 }
        });
      }
      break;
  }

  res.status(200).json({ received: true });
});

// Outbound call trigger endpoint
app.post('/trigger-call', async (req, res) => {
  const { phoneNumber, customerName } = req.body;

  try {
    const response = await fetch('https://api.vapi.ai/call', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.VAPI_API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        assistant: assistantConfig,
        phoneNumber: phoneNumber,
        customer: { name: customerName }
      })
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const call = await response.json();
    res.json({ callId: call.id, status: 'initiated' });
  } catch (error) {
    console.error('Call initiation failed:', error);
    res.status(500).json({ error: error.message });
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Lead qualification server running on port ${PORT}`);
});

# .env file
VAPI_API_KEY=your_vapi_key_here
VAPI_SERVER_SECRET=your_webhook_secret_here
SALES_PHONE_NUMBER=+1234567890
PORT=3000

npm install express
node server.js

ngrok http 3000
# Update Vapi dashboard: Server URL = https://YOUR_ID.ngrok.io/webhook/vapi

curl -X POST http://localhost:3000/trigger-call \
  -H "Content-Type: application/json" \
  -d '{"phoneNumber": "+1234567890", "customerName": "John Doe"}'