Jjj

Paused

App Files Files Community

Pepguy commited on Jun 22

Commit

22cfb93

verified ·

1 Parent(s): 33ad64d

Update app.js

Browse files

Files changed (1) hide show

app.js +325 -133

app.js CHANGED Viewed

@@ -24,6 +24,68 @@ const log = (tag, ...args) => {
 let callLogs = [];
 // ─────────────────────────────────────────────
 // 1. EMBEDDED DASHBOARD
 // ─────────────────────────────────────────────
@@ -34,7 +96,7 @@ app.get("/", (req, res) => {
     <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
-      <title>Telecom Control Panel</title>
       <script src="https://cdn.tailwindcss.com"></script>
       <script src="https://unpkg.com/react@18.2.0/umd/react.production.min.js"></script>
       <script src="https://unpkg.com/react-dom@18.2.0/umd/react-dom.production.min.js"></script>
@@ -96,13 +158,16 @@ app.get("/", (req, res) => {
               <div className="bg-gray-800 rounded-lg overflow-hidden shadow-lg">
                 <table className="w-full text-left">
                   <thead className="bg-gray-900 text-gray-400 text-sm">
-                    <tr><th className="p-4">Call ID</th><th className="p-4">Number</th><th className="p-4">Status</th><th className="p-4">Action</th><th className="p-4">Recording</th></tr>
                   </thead>
                   <tbody className="divide-y divide-gray-700">
                     {logs.map(log => (
                       <tr key={log.id}>
                         <td className="p-4 text-xs font-mono text-gray-500">{log.call_control_id.slice(0,8)}...</td>
                         <td className="p-4 font-mono">{log.target_number}</td>
                         <td className="p-4">
                           <div className="flex flex-col gap-1">
                             <span className={\`inline-block w-fit px-2 py-1 rounded text-xs \${log.status === 'completed' ? 'bg-green-900 text-green-300' : 'bg-yellow-900 text-yellow-300'}\`}>
@@ -116,9 +181,7 @@ app.get("/", (req, res) => {
                             <button onClick={() => hangup(log.call_control_id)} className="bg-red-600 hover:bg-red-500 text-xs px-3 py-1 rounded font-bold transition">
                               Force Hang Up
                             </button>
-                          ) : (
-                            <span className="text-gray-500 text-xs">Ended</span>
-                          )}
                         </td>
                         <td className="p-4">
                           {log.recording_url ?
@@ -128,7 +191,7 @@ app.get("/", (req, res) => {
                         </td>
                       </tr>
                     ))}
-                    {logs.length === 0 && <tr><td colSpan="5" className="p-4 text-center text-gray-500">No calls registered yet</td></tr>}
                   </tbody>
                 </table>
               </div>
@@ -142,16 +205,13 @@ app.get("/", (req, res) => {
   `);
 });
-app.get("/api/logs", (req, res) => {
-  res.json([...callLogs].reverse());
-});
 app.get("/health", (req, res) => res.json({ status: "ok", uptime: process.uptime() }));
 app.get("/play-recording/:call_control_id", async (req, res) => {
   const logEntry = callLogs.find(l => l.call_control_id === req.params.call_control_id);
   if (!logEntry || !logEntry.raw_telnyx_url) return res.sendStatus(404);
   try {
     const s3Res = await fetch(logEntry.raw_telnyx_url);
     if (!s3Res.ok) return res.sendStatus(s3Res.status);
@@ -159,27 +219,22 @@ app.get("/play-recording/:call_control_id", async (req, res) => {
     res.setHeader("Content-Type", "audio/mpeg");
     res.setHeader("Content-Length", buffer.length);
     res.send(buffer);
-  } catch (e) {
-    res.sendStatus(500);
-  }
 });
 app.post("/dial", async (req, res) => {
   const { to } = req.body;
   const voice = "Algieba";
   log("DIAL", `Dialing ${to}...`);
   try {
-    const response = await fetch("https://api.telnyx.com/v2/calls", {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Authorization: `Bearer ${TELNYX_API_KEY}` },
-      body: JSON.stringify({
-        connection_id: TELNYX_CONNECTION_ID,
-        to,
-        from: TELNYX_FROM_NUMBER,
-        custom_headers: [{ name: "X-Voice-Selection", value: voice }]
-      }),
-    });
     const data = await response.json();
     if (!response.ok) return res.status(400).json({ ok: false, error: data?.errors?.[0]?.detail });
@@ -190,32 +245,26 @@ app.post("/dial", async (req, res) => {
       target_number: to,
       voice_used: voice,
       status: "dialing",
-      has_spoken: false,
-      is_playing: false, // Tracks if AI is currently making noise
       recording_url: null,
       raw_telnyx_url: null,
       created_at: new Date().toISOString()
     });
     res.json({ ok: true });
-  } catch (err) {
-    res.status(500).json({ ok: false, error: err.message });
-  }
 });
 app.post("/call/hangup", async (req, res) => {
   const { call_control_id } = req.body;
-  try {
-    await fetch(`https://api.telnyx.com/v2/calls/${call_control_id}/actions/hangup`, {
-      method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${TELNYX_API_KEY}` }, body: JSON.stringify({}),
-    });
-    res.json({ ok: true });
-  } catch (err) {
-    res.status(500).json({ ok: false, error: err.message });
-  }
 });
-// ─── TELNYX WEBHOOK (Barge-in & Smart Greeting) ──
 app.post("/webhook/call", async (req, res) => {
   const type = req.body?.data?.event_type;
   const payload = req.body?.data?.payload;
@@ -223,124 +272,267 @@ app.post("/webhook/call", async (req, res) => {
   if (!type) return res.sendStatus(200);
-  const telnyxCmd = async (action, body = {}) => {
-    try {
-      const response = await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/${action}`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${TELNYX_API_KEY}` },
-        body: JSON.stringify(body)
-      });
-      if (!response.ok) log("TELNYX CMD ERROR", `[${action}] failed (${response.status})`);
-      return response;
-    } catch (e) {
-      log("TELNYX CMD NETWORK ERROR", e.message);
-    }
-  };
-  const updateLog = (statusUpdates) => {
-    const entry = callLogs.find(l => l.call_control_id === callId);
-    if (entry) Object.assign(entry, statusUpdates);
-    return entry;
-  };
-  try {
-    switch (type) {
-      case "call.answered":
-        log("ANSWERED", `Call connected.`);
-        const ansEntry = updateLog({ status: "in-progress", is_playing: false, has_spoken: false });
-        await telnyxCmd("record_start", { format: "mp3", channels: "dual", play_beep: false });
-        await telnyxCmd("transcription_start", { transcription_engine: "Telnyx", transcription_tracks: "inbound" });
-        // Smart Greeting: If the human says nothing for 3.5 seconds, we say "Hello?"
         setTimeout(async () => {
-          const checkEntry = callLogs.find(l => l.call_control_id === callId);
-          if (checkEntry && !checkEntry.has_spoken && checkEntry.status === "in-progress") {
-            log("SILENCE_TIMEOUT", "Human is silent. Prompting with 'Hello.'");
-            const voice = checkEntry.voice_used || "Algieba";
-            const phrase = encodeURIComponent("Hello.");
-            updateLog({ is_playing: true });
-            await telnyxCmd("playback_start", {
-              audio_url: `${AI_SERVER_URL}/play-audio?voice=${voice}&phrase=${phrase}`,
-              target_legs: "self"
-            });
           }
-        }, 3500);
-        // Safety net hangup
-        setTimeout(async () => { await telnyxCmd("hangup", {}); }, 60000);
-        break;
-      case "call.transcription":
-        const data = payload?.transcription_data;
-        if (data) {
-          updateLog({ has_spoken: true });
-          // 1. THE BARGE-IN: User is speaking (interim result)
-          if (!data.is_final) {
-            const entry = callLogs.find(l => l.call_control_id === callId);
-            // If the AI is currently playing audio, stop it immediately!
             if (entry && entry.is_playing) {
-              log("BARGE-IN", "Human interrupted! Stopping AI playback.");
-              updateLog({ is_playing: false });
-              await telnyxCmd("playback_stop", {});
             }
-            return res.sendStatus(200); // Exit early, wait for final transcript
           }
-          // 2. TURN END: User finished speaking
-          if (data.is_final) {
-            const transcript = data.transcript;
-            const entry = callLogs.find(l => l.call_control_id === callId);
             const voice = entry ? entry.voice_used : "Algieba";
-            log("TRANSCRIPT", `User said: "${transcript}"`);
             try {
-              // Pass call_id so AI Server can remember the history
-              const aiRes = await fetch(`${AI_SERVER_URL}/api/process-text-turn`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ text: transcript, voice: voice, call_id: callId })
               });
               if (aiRes.ok) {
                 const aiData = await aiRes.json();
-                if (aiData.speak_url) {
-                  log("AI_REPLY", `Playing reply.`);
-                  updateLog({ is_playing: true }); // Mark AI as speaking
-                  await telnyxCmd("playback_start", {
-                    audio_url: aiData.speak_url,
-                    target_legs: "self"
                   });
                 }
               }
             } catch (e) { log("AI_SERVER_ERROR", e.message); }
           }
         }
-        break;
-      // Track when the AI naturally finishes its sentence
-      case "call.playback.ended":
-      case "call.playback.stopped":
-        updateLog({ is_playing: false });
-        break;
-      case "call.recording.saved":
-        updateLog({ status: "completed", raw_telnyx_url: payload.recording_urls.mp3, recording_url: `/play-recording/${callId}` });
-        break;
-      case "call.hangup":
-        updateLog({ status: "completed", is_playing: false });
-        log("CALL ENDED", `Terminated.`);
-        break;
-    }
-  } catch (fatalError) {
-    log("WEBHOOK FATAL ERROR", fatalError.message);
   }
-  res.sendStatus(200);
 });
 server.listen(PORT, "0.0.0.0", () => {
-  log("STARTUP", `Telecom Server running on port ${PORT}`);
 });

 let callLogs = [];
+// ─── UTILITY: GLOBAL TELNYX COMMAND DISPATCHER ───
+const sendTelnyxCmd = async (callId, action, body = {}) => {
+  try {
+    const response = await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/${action}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${TELNYX_API_KEY}` },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) log("TELNYX CMD ERROR", `[${action}] failed (${response.status}): ${await response.text()}`);
+    return response;
+  } catch (e) {
+    log("TELNYX CMD NETWORK ERROR", e.message);
+  }
+};
+const updateLog = (callId, statusUpdates) => {
+  const entry = callLogs.find(l => l.call_control_id === callId);
+  if (entry) Object.assign(entry, statusUpdates);
+  return entry;
+};
+// ─── VAD MATH UTILITIES ───
+const MU_LAW_TABLE = new Int16Array(256);
+for (let i = 0; i < 256; i++) {
+  let sign = (i & 0x80) ? -1 : 1;
+  let exponent = (~i >> 4) & 0x07;
+  let mantissa = ~i & 0x0f;
+  let sample = ((mantissa << 3) + 132) << exponent;
+  MU_LAW_TABLE[i] = sign * (sample - 132);
+}
+function decodeMuLaw(buffer) {
+  const pcm16 = new Int16Array(buffer.length);
+  for (let i = 0; i < buffer.length; i++) { pcm16[i] = MU_LAW_TABLE[buffer[i]]; }
+  return pcm16;
+}
+function calculateRMS(pcm16Array) {
+  let sum = 0;
+  for (let i = 0; i < pcm16Array.length; i++) sum += pcm16Array[i] * pcm16Array[i];
+  return Math.sqrt(sum / pcm16Array.length);
+}
+function pcm16ToWav(pcm16Array, sampleRate = 8000) {
+  const pcmBuffer = Buffer.from(pcm16Array.buffer);
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + pcmBuffer.length, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20); // PCM
+  header.writeUInt16LE(1, 22); // Mono
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28); // ByteRate
+  header.writeUInt16LE(2, 32); // BlockAlign
+  header.writeUInt16LE(16, 34); // BitsPerSample
+  header.write("data", 36);
+  header.writeUInt32LE(pcmBuffer.length, 40);
+  return Buffer.concat([header, pcmBuffer]);
+}
 // ─────────────────────────────────────────────
 // 1. EMBEDDED DASHBOARD
 // ─────────────────────────────────────────────
     <head>
       <meta charset="UTF-8">
       <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>Elite Telecom Control Panel</title>
       <script src="https://cdn.tailwindcss.com"></script>
       <script src="https://unpkg.com/react@18.2.0/umd/react.production.min.js"></script>
       <script src="https://unpkg.com/react-dom@18.2.0/umd/react-dom.production.min.js"></script>
               <div className="bg-gray-800 rounded-lg overflow-hidden shadow-lg">
                 <table className="w-full text-left">
                   <thead className="bg-gray-900 text-gray-400 text-sm">
+                    <tr><th className="p-4">Call ID</th><th className="p-4">Number</th><th className="p-4">Last Transcript</th><th className="p-4">Status</th><th className="p-4">Action</th><th className="p-4">Recording</th></tr>
                   </thead>
                   <tbody className="divide-y divide-gray-700">
                     {logs.map(log => (
                       <tr key={log.id}>
                         <td className="p-4 text-xs font-mono text-gray-500">{log.call_control_id.slice(0,8)}...</td>
                         <td className="p-4 font-mono">{log.target_number}</td>
+                        <td className="p-4 text-xs text-gray-300 italic truncate max-w-[200px]" title={log.last_transcript}>
+                          {log.last_transcript || "..."}
+                        </td>
                         <td className="p-4">
                           <div className="flex flex-col gap-1">
                             <span className={\`inline-block w-fit px-2 py-1 rounded text-xs \${log.status === 'completed' ? 'bg-green-900 text-green-300' : 'bg-yellow-900 text-yellow-300'}\`}>
                             <button onClick={() => hangup(log.call_control_id)} className="bg-red-600 hover:bg-red-500 text-xs px-3 py-1 rounded font-bold transition">
                               Force Hang Up
                             </button>
+                          ) : <span className="text-gray-500 text-xs">Ended</span>}
                         </td>
                         <td className="p-4">
                           {log.recording_url ?
                         </td>
                       </tr>
                     ))}
+                    {logs.length === 0 && <tr><td colSpan="6" className="p-4 text-center text-gray-500">No calls registered yet</td></tr>}
                   </tbody>
                 </table>
               </div>
   `);
 });
+app.get("/api/logs", (req, res) => res.json([...callLogs].reverse()));
 app.get("/health", (req, res) => res.json({ status: "ok", uptime: process.uptime() }));
+// ─── PROXY FOR TELNYX RECORDINGS ─────────────
 app.get("/play-recording/:call_control_id", async (req, res) => {
   const logEntry = callLogs.find(l => l.call_control_id === req.params.call_control_id);
   if (!logEntry || !logEntry.raw_telnyx_url) return res.sendStatus(404);
   try {
     const s3Res = await fetch(logEntry.raw_telnyx_url);
     if (!s3Res.ok) return res.sendStatus(s3Res.status);
     res.setHeader("Content-Type", "audio/mpeg");
     res.setHeader("Content-Length", buffer.length);
     res.send(buffer);
+  } catch (e) { res.sendStatus(500); }
 });
+// ─── DIAL OUT ROUTE ──────────────────────────
 app.post("/dial", async (req, res) => {
   const { to } = req.body;
   const voice = "Algieba";
   log("DIAL", `Dialing ${to}...`);
   try {
+    const response = await sendTelnyxCmd("", "v2/calls", {
+      connection_id: TELNYX_CONNECTION_ID,
+      to,
+      from: TELNYX_FROM_NUMBER,
+      custom_headers: [{ name: "X-Voice-Selection", value: voice }]
+    }, true);
     const data = await response.json();
     if (!response.ok) return res.status(400).json({ ok: false, error: data?.errors?.[0]?.detail });
       target_number: to,
       voice_used: voice,
       status: "dialing",
+      last_transcript: "",
       recording_url: null,
       raw_telnyx_url: null,
+      is_playing: false,
+      timers: {},
       created_at: new Date().toISOString()
     });
     res.json({ ok: true });
+  } catch (err) { res.status(500).json({ ok: false, error: err.message }); }
 });
+// ─── MANUAL HANG UP ──────────────────────────
 app.post("/call/hangup", async (req, res) => {
   const { call_control_id } = req.body;
+  if (!call_control_id) return res.status(400).json({ error: "Missing call_control_id" });
+  await sendTelnyxCmd(call_control_id, "hangup");
+  res.json({ ok: true });
 });
+// ─── TELNYX WEBHOOK (State Only, No STT) ──────
 app.post("/webhook/call", async (req, res) => {
   const type = req.body?.data?.event_type;
   const payload = req.body?.data?.payload;
   if (!type) return res.sendStatus(200);
+  const entry = callLogs.find(l => l.call_control_id === callId);
+  if (entry && entry.status === "completed" && type !== "call.recording.saved") {
+    return res.sendStatus(200);
+  }
+  switch (type) {
+    case "call.initiated":
+      log("INITIATED", `from=${payload?.from} to=${payload?.to}`);
+      if (payload?.direction === "incoming") {
+        log("INBOUND", "Answering inbound call...");
+        fetch(`${AI_SERVER_URL}/api/inbound-call`, {
+          method: "POST", headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ from: payload?.from, to: payload?.to, call_id: callId })
+        }).catch(() => {});
+        callLogs.push({
+          id: randomUUID(), call_control_id: callId, target_number: payload?.from,
+          voice_used: "Algieba", status: "in-progress", last_transcript: "", recording_url: null,
+          raw_telnyx_url: null, is_playing: false, timers: {}, created_at: new Date().toISOString()
+        });
+        await sendTelnyxCmd(callId, "answer");
+      }
+      break;
+    case "call.answered":
+      log("ANSWERED", `Call ${callId} connected.`);
+      updateLog(callId, { status: "in-progress" });
+      await sendTelnyxCmd(callId, "record_start", { format: "mp3", channels: "dual", play_beep: false });
+      // Start WebSocket Media Stream to listen to the caller natively
+      const wsUrl = `wss://${req.headers.host}/audio-stream`;
+      await sendTelnyxCmd(callId, "stream_start", { stream_url: wsUrl, track: "inbound_track" });
+      if (entry) {
+        entry.timers.hangup = setTimeout(async () => {
+          if (entry.status === "completed") return;
+          log("HANGUP", `Enforcing 60-second limit.`);
+          await sendTelnyxCmd(callId, "hangup");
+        }, 60000);
+      }
+      break;
+    case "call.playback.ended":
+    case "call.playback.stopped":
+      updateLog(callId, { is_playing: false });
+      break;
+    case "call.recording.saved":
+      log("RECORDING URL", `\n\n⬇️ DOWNLOAD RAW AUDIO HERE ⬇️\n${payload.recording_urls.mp3}\n`);
+      updateLog(callId, {
+        raw_telnyx_url: payload.recording_urls.mp3,
+        recording_url: `/play-recording/${callId}`
+      });
+      break;
+    case "call.hangup":
+      updateLog(callId, { status: "completed", is_playing: false });
+      if (entry && entry.timers) {
+        Object.values(entry.timers).forEach(clearTimeout);
+        entry.timers = {};
+      }
+      log("CALL ENDED", `Terminated.`);
+      break;
+  }
+  res.sendStatus(200);
+});
+// ─── WEBSOCKET (Zero-Dependency VAD & Turn Engine) ───
+wss.on("connection", (ws, req) => {
+  log("WS", `VAD WebSocket connected from ${req.socket.remoteAddress}`);
+  let pcmChunks = [];
+  let isSpeaking = false;
+  let silenceFrames = 0;
+  let callControlId = null;
+  let isProcessingTurn = false;
+  let hasGreeted = false;
+  const SILENCE_THRESHOLD_FRAMES = 25; // 25 frames * 20ms = 500ms of silence
+  const VOLUME_THRESHOLD = 400; // RMS Volume Threshold
+  ws.on("message", async (raw) => {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.event === "start") {
+        callControlId = msg.start?.call_control_id;
+        log("WS_STREAM", `Receiving audio for call ${callControlId}`);
+        // Smart Initial Greeting
         setTimeout(async () => {
+          if (!hasGreeted && callControlId) {
+             const entry = callLogs.find(l => l.call_control_id === callControlId);
+             if (entry && entry.status === "in-progress") {
+               const voice = entry.voice_used || "Algieba";
+               log("SMART_GREETING", "No immediate human audio detected. Saying Hello.");
+               entry.is_playing = true;
+               hasGreeted = true;
+               await sendTelnyxCmd(callControlId, "playback_start", {
+                 audio_url: `${AI_SERVER_URL}/play-audio?voice=${voice}&phrase=${encodeURIComponent("am I speaking with the business owner?")}`,
+                 target_legs: "self"
+               });
+             }
           }
+        }, 1500);
+      }
+      if (msg.event === "media") {
+        const mulawBuffer = Buffer.from(msg.media.payload, "base64");
+        const pcm16 = decodeMuLaw(mulawBuffer);
+        const rms = calculateRMS(pcm16);
+        // ── 1. NOISE DETECTED (Human is speaking) ──
+        if (rms > VOLUME_THRESHOLD) {
+          hasGreeted = true; // They spoke, disable smart greeting timer
+          silenceFrames = 0;
+          pcmChunks.push(pcm16);
+          if (!isSpeaking) {
+            isSpeaking = true;
+            isProcessingTurn = false;
+            log("VAD", "Human started speaking.");
+            // ── BARGE IN ──
+            const entry = callLogs.find(l => l.call_control_id === callControlId);
             if (entry && entry.is_playing) {
+              log("BARGE-IN", "Interrupting AI playback.");
+              entry.is_playing = false;
+              await sendTelnyxCmd(callControlId, "playback_stop");
             }
           }
+        }
+        // ── 2. SILENCE DETECTED ──
+        else if (isSpeaking) {
+          pcmChunks.push(pcm16);
+          silenceFrames++;
+          // ── 3. SOFT TURN TRIGGER (500ms silence limit reached) ──
+          if (silenceFrames > SILENCE_THRESHOLD_FRAMES && !isProcessingTurn) {
+            log("VAD", "500ms silence detected. Turn ended.");
+            isSpeaking = false;
+            isProcessingTurn = true;
+            silenceFrames = 0;
+            const entry = callLogs.find(l => l.call_control_id === callControlId);
             const voice = entry ? entry.voice_used : "Algieba";
+            // Compile WAV buffer for Groq
+            const totalLength = pcmChunks.reduce((acc, val) => acc + val.length, 0);
+            const finalPcm = new Int16Array(totalLength);
+            let offset = 0;
+            for (let chunk of pcmChunks) { finalPcm.set(chunk, offset); offset += chunk.length; }
+            pcmChunks = []; // Clear for next turn
+            // If the noise burst was less than ~200ms total, ignore it (mic bump/cough)
+            if (totalLength < 8000 * 0.2) {
+               isProcessingTurn = false;
+               return;
+            }
+            const wavBuffer = pcm16ToWav(finalPcm, 8000);
+            // ── IMMEDIATE BACKCHANNEL HACK (0ms perceived latency) ──
+            const fillers = ["Right.", "Got it.", "Okay."];
+            const filler = fillers[Math.floor(Math.random() * fillers.length)];
+            if (entry) entry.is_playing = true;
+            sendTelnyxCmd(callControlId, "playback_start", {
+              audio_url: `${AI_SERVER_URL}/play-audio?voice=${voice}&phrase=${encodeURIComponent(filler)}`,
+              target_legs: "self"
+            }).catch(()=>{});
+            // ── BACKGROUND AI PROCESSING ──
             try {
+              const aiRes = await fetch(`${AI_SERVER_URL}/api/process-audio-turn?voice=${voice}&call_id=${callControlId}`, {
+                method: "POST", headers: { "Content-Type": "audio/wav" }, body: wavBuffer
               });
               if (aiRes.ok) {
                 const aiData = await aiRes.json();
+                if (aiData.transcript) updateLog(callControlId, { last_transcript: aiData.transcript });
+                // Check race condition: Did human interrupt the AI thinking?
+                if (!isSpeaking && aiData.speak_url) {
+                  log("AI_REPLY", `Playing reply: ${aiData.raw_text}`);
+                  if (entry) entry.is_playing = true;
+                  await sendTelnyxCmd(callControlId, "playback_start", {
+                    audio_url: aiData.speak_url, target_legs: "self"
                   });
+                } else {
+                  log("TURN_DROPPED", "User resumed speaking. Dropping response.");
                 }
               }
             } catch (e) { log("AI_SERVER_ERROR", e.message); }
           }
         }
+      }
+    } catch (err) { log("WS PARSE ERROR", err.message); }
+  });
+});
+// Custom fetch wrapper for internal call initiation without full endpoint
+const originalFetch = global.fetch;
+global.fetch = async (url, options) => {
+  if (url === "https://api.telnyx.com/v2/calls" && options?.method === "POST" && options?.isCustomDial) {
+    const rawUrl = url;
+    delete options.isCustomDial;
+    return originalFetch(rawUrl, options);
   }
+  return originalFetch(url, options);
+};
+// Replace Dial API implementation to use standard fetch safely
+app.post("/dial", async (req, res) => {
+  const { to } = req.body;
+  const voice = "Algieba";
+  log("DIAL", `Dialing ${to}...`);
+  try {
+    const response = await fetch("https://api.telnyx.com/v2/calls", {
+      method: "POST",
+      isCustomDial: true,
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${TELNYX_API_KEY}` },
+      body: JSON.stringify({
+        connection_id: TELNYX_CONNECTION_ID,
+        to,
+        from: TELNYX_FROM_NUMBER,
+        custom_headers: [{ name: "X-Voice-Selection", value: voice }]
+      }),
+    });
+    const data = await response.json();
+    if (!response.ok) return res.status(400).json({ ok: false, error: data?.errors?.[0]?.detail });
+    callLogs.push({
+      id: randomUUID(),
+      call_control_id: data.data.call_control_id,
+      target_number: to,
+      voice_used: voice,
+      status: "dialing",
+      last_transcript: "",
+      recording_url: null,
+      raw_telnyx_url: null,
+      is_playing: false,
+      timers: {},
+      created_at: new Date().toISOString()
+    });
+    res.json({ ok: true });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: err.message });
+  }
+});
+const requiredEnv = ["TELNYX_API_KEY", "TELNYX_CONNECTION_ID", "TELNYX_FROM_NUMBER", "AI_SERVER_URL"];
+requiredEnv.forEach((key) => {
+  if (!process.env[key]) log("STARTUP WARNING", `Missing env var: ${key}`);
 });
 server.listen(PORT, "0.0.0.0", () => {
+  log("STARTUP", `Elite Telecom Server running on port ${PORT}`);
 });