Asterisk AGI vs ARI: Which API Should You Use in 2026?

#!/usr/bin/env python3
"""
FastAGI PIN validation server for Asterisk.
Dialplan: exten => s,1,FastAGI(agi://127.0.0.1:4573)
"""
import socketserver
import threading
from asterisk.agi import AGI  # pip install pyst2

# Simulated PIN database
VALID_PINS = {"1234": "support_queue", "5678": "sales_queue", "9999": "admin_queue"}


class AGIHandler(socketserver.BaseRequestHandler):
    def handle(self):
        agi = AGI(wfile=self.request.makefile("w"), rfile=self.request.makefile("r"))

        try:
            # Answer the call
            agi.answer()

            # Get caller ID for logging
            caller_id = agi.get_variable("CALLERID(num)")
            print(f"[FastAGI] Incoming call from {caller_id}")

            attempts = 0
            while attempts < 3:
                # Play PIN prompt
                agi.stream_file("please-enter-your-pin", escape_digits="0123456789#")

                # Collect 4 digits, 5s timeout
                digits = agi.get_data("beep", timeout=5000, max_digits=4)

                if digits and digits in VALID_PINS:
                    queue_name = VALID_PINS[digits]
                    agi.verbose(f"Valid PIN {digits} → queue {queue_name}", 2)
                    agi.stream_file("auth-thankyou")
                    # Transfer to the appropriate queue via dialplan exec
                    agi.execute("Queue", f"{queue_name},t,,,60")
                    return
                else:
                    attempts += 1
                    agi.stream_file("auth-incorrect")

            # 3 failed attempts — play sorry and hang up
            agi.stream_file("vm-sorry")
            agi.hangup()

        except Exception as e:
            print(f"[FastAGI] Error: {e}")


class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
    allow_reuse_address = True
    daemon_threads = True


if __name__ == "__main__":
    server = ThreadedTCPServer(("0.0.0.0", 4573), AGIHandler)
    print("[FastAGI] Listening on port 4573...")
    server.serve_forever()

const ari = require('ari-client');  // npm install ari-client
const OpenAI = require('openai');

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

ari.connect('http://localhost:8088', 'asterisk', 'asterisk', (err, client) => {
  if (err) throw err;
  console.log('[ARI] Connected to Asterisk');

  // Register our Stasis application name
  // Dialplan: exten => s,1,Stasis(ai-voice-bot)
  client.start('ai-voice-bot');

  // Handle incoming calls
  client.on('StasisStart', async (event, channel) => {
    console.log(`[ARI] StasisStart: ${channel.id} from ${channel.caller.number}`);

    try {
      // Answer the channel
      await channel.answer();

      // Play a greeting while we warm up
      const greeting = await channel.play({ media: 'sound:hello-world' });

      // Wait for greeting to finish before listening
      greeting.on('PlaybackFinished', async () => {
        // Start a live recording — 5s max, stop on silence
        const recording = await channel.record({
          name: `rec_${channel.id}`,
          format: 'wav',
          maxDurationSeconds: 5,
          maxSilenceSeconds: 1,
          beep: true,
        });

        recording.on('RecordingFinished', async (recEvent) => {
          const audioFile = recEvent.recording.name;
          console.log(`[ARI] Recording complete: ${audioFile}`);

          // Transcribe with Whisper (simplified — in prod, fetch the file)
          const transcript = await transcribeAudio(audioFile);
          console.log(`[ARI] Transcript: ${transcript}`);

          // Get LLM response
          const llmReply = await getLLMResponse(transcript, channel.caller.number);
          console.log(`[ARI] LLM reply: ${llmReply}`);

          // Convert to speech and play
          const ttsFile = await synthesizeSpeech(llmReply);
          await channel.play({ media: `sound:${ttsFile}` });
        });
      });

    } catch (e) {
      console.error('[ARI] Error:', e.message);
      await channel.hangup().catch(() => {});
    }
  });

  client.on('StasisEnd', (event, channel) => {
    console.log(`[ARI] Call ended: ${channel.id}`);
  });
});

async function getLLMResponse(userInput, callerId) {
  const completion = await openai.chat.completions.create({
    model: 'gpt-4o',
    messages: [
      { role: 'system', content: 'You are a helpful phone assistant. Be brief — under 50 words.' },
      { role: 'user', content: userInput },
    ],
    max_tokens: 100,
  });
  return completion.choices[0].message.content;
}

// Stubs — implement with your ASR/TTS provider
async function transcribeAudio(file) { return "How do I reset my password?"; }
async function synthesizeSpeech(text) { return "tts-response"; }