Plug Sonar into your outbound calls

{"type": "verdict", "call_id": "CA1234...", "verdict": "machine", "label": "operator_msg",
 "event": "confirmed", "action": "hangup", "t_decision": 8.4}

{"type": "beep", "call_id": "CA1234...", "t": 15.04}

{"type": "final", "call_id": "CA1234...", "audio_seconds": 20.4, "verdict": "machine",
 "label": "operator_msg", "action": "hangup", "beep": true}

{"type": "error", "code": 401, "message": "clé API invalide ou révoquée"}

"""One Sonar session per Twilio call. Fail-open: any error lets the call go on."""
import asyncio, base64, json, os

import websockets
from twilio.rest import Client

SONAR_URL = "wss://167-233-100-203.sslip.io/v1/stream"
SONAR_KEY = os.environ["SONAR_API_KEY"]
SHADOW = os.environ.get("SONAR_SHADOW", "1") == "1"   # 1 = log only, never hang up
twilio = Client(os.environ["TWILIO_ACCOUNT_SID"], os.environ["TWILIO_AUTH_TOKEN"])


class SonarSession:
    def __init__(self, call_sid: str):
        self.call_sid = call_sid
        self.ws = None
        self.waiting_beep = False
        self.done = False

    async def start(self):
        try:
            self.ws = await websockets.connect(SONAR_URL, open_timeout=3)
            await self.ws.send(json.dumps({
                "type": "start", "api_key": SONAR_KEY, "call_id": self.call_sid,
                "sample_rate": 8000, "format": "mulaw"}))
            asyncio.create_task(self._read())
        except Exception:
            self.ws = None

    async def feed(self, payload_b64: str):
        if self.ws and not self.done:
            try:
                await self.ws.send(base64.b64decode(payload_b64))
            except Exception:
                self.ws = None

    async def stop(self):
        if self.ws:
            try:
                await self.ws.send(json.dumps({"type": "end"}))
                await self.ws.close()
            except Exception:
                pass

    async def _read(self):
        try:
            async for raw in self.ws:
                m = json.loads(raw)
                if m["type"] == "verdict":
                    if m["action"] == "hangup" and m["event"] in ("confirmed", "final", "update"):
                        await self._hangup(f'{m["event"]}:{m["label"]}')
                    elif m["action"] == "wait" or m["event"] == "revoked":
                        self.waiting_beep = True
                elif m["type"] == "beep" and self.waiting_beep:
                    await self._hangup("beep")
                elif m["type"] == "final":
                    print("sonar final", self.call_sid, m)   # log it on your side
        except Exception:
            pass

    async def _hangup(self, reason: str):
        if self.done:
            return
        self.done = True
        print("sonar hangup", self.call_sid, reason, "(shadow)" if SHADOW else "")
        if not SHADOW:
            await asyncio.to_thread(twilio.calls(self.call_sid).update, status="completed")


# In your Twilio WebSocket handler:
#   event "start" → sonar = SonarSession(msg["start"]["callSid"]); await sonar.start()
#   event "media" → if msg["media"].get("track", "inbound") == "inbound":
#                       await sonar.feed(msg["media"]["payload"])
#   event "stop"  → await sonar.stop()

/** One Sonar session per Twilio call. Fail-open: any error lets the call go on. */
import WebSocket from "ws";
import twilio from "twilio";

const SONAR_URL = "wss://167-233-100-203.sslip.io/v1/stream";
const SONAR_KEY = process.env.SONAR_API_KEY ?? "";
const SHADOW = (process.env.SONAR_SHADOW ?? "1") === "1"; // 1 = log only, never hang up
const client = twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);

type SonarMessage =
  | { type: "verdict"; call_id: string; verdict: "machine" | "human"; label: string;
      event: "provisional" | "confirmed" | "final" | "update" | "revoked";
      action: "hangup" | "wait" | "continue"; t_decision: number }
  | { type: "beep"; call_id: string; t: number }
  | { type: "final"; call_id: string; audio_seconds: number; verdict: "machine" | "human" | "no_decision";
      label: string | null; action: string | null; beep: boolean }
  | { type: "error"; code: number; message: string };

export class SonarSession {
  private ws: WebSocket | null = null;
  private pending: Buffer[] = []; // audio received while connecting to Sonar
  private waitingBeep = false;
  private done = false;

  constructor(private readonly callSid: string) {}

  start(): void {
    try {
      const ws = new WebSocket(SONAR_URL, { handshakeTimeout: 3000 });
      ws.on("open", () => {
        ws.send(JSON.stringify({ type: "start", api_key: SONAR_KEY, call_id: this.callSid,
                                 sample_rate: 8000, format: "mulaw" }));
        for (const chunk of this.pending) ws.send(chunk);
        this.pending = [];
      });
      ws.on("message", (raw) => {
        try {
          void this.onMessage(JSON.parse(raw.toString()) as SonarMessage);
        } catch {
          // unreadable message: ignored
        }
      });
      ws.on("error", () => { this.ws = null; });
      ws.on("close", () => { this.ws = null; });
      this.ws = ws;
    } catch {
      this.ws = null;
    }
  }

  feed(payloadB64: string): void {
    const ws = this.ws;
    if (!ws || this.done) return;
    const chunk = Buffer.from(payloadB64, "base64");
    if (ws.readyState === WebSocket.OPEN) ws.send(chunk);
    else if (ws.readyState === WebSocket.CONNECTING && this.pending.length < 250) this.pending.push(chunk);
  }

  stop(): void {
    const ws = this.ws;
    if (!ws) return;
    try {
      // Sonar answers with "final", then closes the connection itself
      if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: "end" }));
      setTimeout(() => ws.close(), 5000).unref();
    } catch {
      // fail-open
    }
  }

  private async onMessage(m: SonarMessage): Promise<void> {
    if (m.type === "verdict") {
      if (m.action === "hangup" && (m.event === "confirmed" || m.event === "final" || m.event === "update")) {
        await this.hangup(`${m.event}:${m.label}`);
      } else if (m.action === "wait" || m.event === "revoked") {
        this.waitingBeep = true;
      }
    } else if (m.type === "beep" && this.waitingBeep) {
      await this.hangup("beep");
    } else if (m.type === "final") {
      console.log("sonar final", this.callSid, m); // log it on your side
    }
  }

  private async hangup(reason: string): Promise<void> {
    if (this.done) return;
    this.done = true;
    console.log("sonar hangup", this.callSid, reason, SHADOW ? "(shadow)" : "");
    if (!SHADOW) {
      try {
        await client.calls(this.callSid).update({ status: "completed" });
      } catch {
        // the call may already be over
      }
    }
  }
}

// In your Twilio WebSocket handler:
//   event "start" → const sonar = new SonarSession(msg.start.callSid); sonar.start();
//   event "media" → if ((msg.media.track ?? "inbound") === "inbound") sonar.feed(msg.media.payload);
//   event "stop"  → sonar.stop();