Rename TwilioService to CallerService, remove Twilio-specific audio encoding

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/main.py

@@ -17,7 +17,7 @@ from pydantic import BaseModel
 from typing import Optional
 
 from .config import settings
-from .services.twilio_service import TwilioService
+from .services.caller_service import CallerService
 from .services.transcription import transcribe_audio
 from .services.llm import llm_service
 from .services.tts import generate_speech
@@ -405,7 +405,7 @@ class Session:
 
 
 session = Session()
-twilio_service = TwilioService()
+caller_service = CallerService()
 
 
 # --- Static Files ---
@@ -672,7 +672,7 @@ async def text_to_speech(request: TTSRequest):
     if session.active_real_caller:
         call_sid = session.active_real_caller["call_sid"]
         asyncio.create_task(
-            twilio_service.send_audio_to_caller(call_sid, audio_bytes, 24000)
+            caller_service.send_audio_to_caller(call_sid, audio_bytes, 24000)
         )
 
     return {"status": "playing", "duration": len(audio_bytes) / 2 / 24000}
@@ -788,7 +788,7 @@ async def twilio_voice_webhook(
     From: str = Form(...),
 ):
     """Handle incoming Twilio call — greet and enqueue"""
-    twilio_service.add_to_queue(CallSid, From)
+    caller_service.add_to_queue(CallSid, From)
 
     response = VoiceResponse()
     response.say("You're calling Luke at the Roost. Hold tight, we'll get to you.", voice="alice")
@@ -812,14 +812,14 @@ async def twilio_hold_music():
 @app.get("/api/queue")
 async def get_call_queue():
     """Get list of callers waiting in queue"""
-    return {"queue": twilio_service.get_queue()}
+    return {"queue": caller_service.get_queue()}
 
 
 @app.post("/api/queue/take/{call_sid}")
 async def take_call_from_queue(call_sid: str):
     """Take a caller off hold and put them on air"""
     try:
-        call_info = twilio_service.take_call(call_sid)
+        call_info = caller_service.take_call(call_sid)
     except ValueError as e:
         raise HTTPException(404, str(e))
 
@@ -851,7 +851,7 @@ async def take_call_from_queue(call_sid: str):
 @app.post("/api/queue/drop/{call_sid}")
 async def drop_from_queue(call_sid: str):
     """Drop a caller from the queue"""
-    twilio_service.remove_from_queue(call_sid)
+    caller_service.remove_from_queue(call_sid)
 
     # Hang up the Twilio call
     from twilio.rest import Client as TwilioClient
@@ -889,9 +889,9 @@ async def twilio_media_stream(websocket: WebSocket):
             if event == "start":
                 stream_sid = msg["start"]["streamSid"]
                 call_sid = msg["start"]["callSid"]
-                twilio_service.register_websocket(call_sid, websocket)
-                if call_sid in twilio_service.active_calls:
-                    twilio_service.active_calls[call_sid]["stream_sid"] = stream_sid
+                caller_service.register_websocket(call_sid, websocket)
+                if call_sid in caller_service.active_calls:
+                    caller_service.active_calls[call_sid]["stream_sid"] = stream_sid
                 print(f"[Twilio WS] Stream started: {stream_sid} for call {call_sid}")
 
             elif event == "media":
@@ -902,7 +902,7 @@ async def twilio_media_stream(websocket: WebSocket):
                 audio_buffer.extend(pcm_data)
 
                 # Get channel for this caller
-                call_info = twilio_service.active_calls.get(call_sid)
+                call_info = caller_service.active_calls.get(call_sid)
                 if call_info:
                     channel = call_info["channel"]
                     # Route PCM to the caller's dedicated Loopback channel
@@ -928,7 +928,7 @@ async def twilio_media_stream(websocket: WebSocket):
         print(f"[Twilio WS] Error: {e}")
     finally:
         if call_sid:
-            twilio_service.unregister_websocket(call_sid)
+            caller_service.unregister_websocket(call_sid)
         # Transcribe any remaining audio
         if audio_buffer and call_sid:
             asyncio.create_task(
@@ -938,7 +938,7 @@ async def twilio_media_stream(websocket: WebSocket):
 
 async def _handle_real_caller_transcription(call_sid: str, pcm_data: bytes, sample_rate: int):
     """Transcribe a chunk of real caller audio and add to conversation"""
-    call_info = twilio_service.active_calls.get(call_sid)
+    call_info = caller_service.active_calls.get(call_sid)
     if not call_info:
         return
 
@@ -1040,7 +1040,7 @@ async def hangup_real_caller():
     ))
 
     # End the Twilio call
-    twilio_service.hangup(call_sid)
+    caller_service.hangup(call_sid)
 
     from twilio.rest import Client as TwilioClient
     if settings.twilio_account_sid and settings.twilio_auth_token:

backend/services/caller_service.py

@@ -0,0 +1,147 @@
+"""Browser caller queue and audio stream service"""
+
+import asyncio
+import time
+import threading
+from typing import Optional
+
+
+class CallerService:
+    """Manages browser caller queue, channel allocation, and WebSocket streams"""
+
+    FIRST_REAL_CHANNEL = 3
+
+    def __init__(self):
+        self._queue: list[dict] = []
+        self.active_calls: dict[str, dict] = {}
+        self._allocated_channels: set[int] = set()
+        self._caller_counter: int = 0
+        self._lock = threading.Lock()
+        self._websockets: dict[str, any] = {}  # caller_id -> WebSocket
+
+    def add_to_queue(self, caller_id: str, name: str):
+        with self._lock:
+            self._queue.append({
+                "caller_id": caller_id,
+                "name": name,
+                "queued_at": time.time(),
+            })
+        print(f"[Caller] {name} added to queue (ID: {caller_id})")
+
+    def remove_from_queue(self, caller_id: str):
+        with self._lock:
+            self._queue = [c for c in self._queue if c["caller_id"] != caller_id]
+        print(f"[Caller] {caller_id} removed from queue")
+
+    def get_queue(self) -> list[dict]:
+        now = time.time()
+        with self._lock:
+            return [
+                {
+                    "caller_id": c["caller_id"],
+                    "name": c["name"],
+                    "wait_time": int(now - c["queued_at"]),
+                }
+                for c in self._queue
+            ]
+
+    def allocate_channel(self) -> int:
+        with self._lock:
+            ch = self.FIRST_REAL_CHANNEL
+            while ch in self._allocated_channels:
+                ch += 1
+            self._allocated_channels.add(ch)
+            return ch
+
+    def release_channel(self, channel: int):
+        with self._lock:
+            self._allocated_channels.discard(channel)
+
+    def take_call(self, caller_id: str) -> dict:
+        caller = None
+        with self._lock:
+            for c in self._queue:
+                if c["caller_id"] == caller_id:
+                    caller = c
+                    break
+            if caller:
+                self._queue = [c for c in self._queue if c["caller_id"] != caller_id]
+
+        if not caller:
+            raise ValueError(f"Caller {caller_id} not in queue")
+
+        channel = self.allocate_channel()
+        self._caller_counter += 1
+        name = caller["name"]
+
+        call_info = {
+            "caller_id": caller_id,
+            "name": name,
+            "channel": channel,
+            "started_at": time.time(),
+        }
+        self.active_calls[caller_id] = call_info
+        print(f"[Caller] {name} taken on air — channel {channel}")
+        return call_info
+
+    def hangup(self, caller_id: str):
+        call_info = self.active_calls.pop(caller_id, None)
+        if call_info:
+            self.release_channel(call_info["channel"])
+            print(f"[Caller] {call_info['name']} hung up — channel {call_info['channel']} released")
+        self._websockets.pop(caller_id, None)
+
+    def reset(self):
+        with self._lock:
+            for call_info in self.active_calls.values():
+                self._allocated_channels.discard(call_info["channel"])
+            self._queue.clear()
+            self.active_calls.clear()
+            self._allocated_channels.clear()
+            self._caller_counter = 0
+            self._websockets.clear()
+        print("[Caller] Service reset")
+
+    def register_websocket(self, caller_id: str, websocket):
+        """Register a WebSocket for a caller"""
+        self._websockets[caller_id] = websocket
+
+    def unregister_websocket(self, caller_id: str):
+        """Unregister a WebSocket"""
+        self._websockets.pop(caller_id, None)
+
+    async def send_audio_to_caller(self, caller_id: str, pcm_data: bytes, sample_rate: int):
+        """Send audio to real caller via WebSocket binary frame"""
+        ws = self._websockets.get(caller_id)
+        if not ws:
+            return
+
+        try:
+            if sample_rate != 16000:
+                import numpy as np
+                import librosa
+                audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
+                audio = librosa.resample(audio, orig_sr=sample_rate, target_sr=16000)
+                pcm_data = (audio * 32767).astype(np.int16).tobytes()
+            await ws.send_bytes(pcm_data)
+        except Exception as e:
+            print(f"[Caller] Failed to send audio: {e}")
+
+    async def notify_caller(self, caller_id: str, message: dict):
+        """Send JSON control message to caller"""
+        ws = self._websockets.get(caller_id)
+        if ws:
+            import json
+            await ws.send_text(json.dumps(message))
+
+    async def disconnect_caller(self, caller_id: str):
+        """Disconnect a caller's WebSocket"""
+        ws = self._websockets.get(caller_id)
+        if ws:
+            try:
+                import json
+                await ws.send_text(json.dumps({"status": "disconnected"}))
+                await ws.close()
+            except Exception:
+                pass
+        self._websockets.pop(caller_id, None)

backend/services/twilio_service.py

@@ -1,148 +0,0 @@
-"""Twilio call queue and media stream service"""
-
-import asyncio
-import base64
-import audioop
-import time
-import threading
-from typing import Optional
-
-
-class TwilioService:
-    """Manages Twilio call queue, channel allocation, and media streams"""
-
-    FIRST_REAL_CHANNEL = 3
-
-    def __init__(self):
-        self._queue: list[dict] = []
-        self.active_calls: dict[str, dict] = {}
-        self._allocated_channels: set[int] = set()
-        self._caller_counter: int = 0
-        self._lock = threading.Lock()
-        self._websockets: dict[str, any] = {}  # call_sid -> WebSocket
-
-    def add_to_queue(self, call_sid: str, phone: str):
-        with self._lock:
-            self._queue.append({
-                "call_sid": call_sid,
-                "phone": phone,
-                "queued_at": time.time(),
-            })
-        print(f"[Twilio] Caller {phone} added to queue (SID: {call_sid})")
-
-    def remove_from_queue(self, call_sid: str):
-        with self._lock:
-            self._queue = [c for c in self._queue if c["call_sid"] != call_sid]
-        print(f"[Twilio] Caller {call_sid} removed from queue")
-
-    def get_queue(self) -> list[dict]:
-        now = time.time()
-        with self._lock:
-            return [
-                {
-                    "call_sid": c["call_sid"],
-                    "phone": c["phone"],
-                    "wait_time": int(now - c["queued_at"]),
-                }
-                for c in self._queue
-            ]
-
-    def allocate_channel(self) -> int:
-        with self._lock:
-            ch = self.FIRST_REAL_CHANNEL
-            while ch in self._allocated_channels:
-                ch += 1
-            self._allocated_channels.add(ch)
-            return ch
-
-    def release_channel(self, channel: int):
-        with self._lock:
-            self._allocated_channels.discard(channel)
-
-    def take_call(self, call_sid: str) -> dict:
-        caller = None
-        with self._lock:
-            for c in self._queue:
-                if c["call_sid"] == call_sid:
-                    caller = c
-                    break
-            if caller:
-                self._queue = [c for c in self._queue if c["call_sid"] != call_sid]
-
-        if not caller:
-            raise ValueError(f"Call {call_sid} not in queue")
-
-        channel = self.allocate_channel()
-        self._caller_counter += 1
-        name = f"Caller #{self._caller_counter}"
-
-        call_info = {
-            "call_sid": call_sid,
-            "phone": caller["phone"],
-            "channel": channel,
-            "name": name,
-            "started_at": time.time(),
-        }
-        self.active_calls[call_sid] = call_info
-        print(f"[Twilio] {name} ({caller['phone']}) taken on air — channel {channel}")
-        return call_info
-
-    def hangup(self, call_sid: str):
-        call_info = self.active_calls.pop(call_sid, None)
-        if call_info:
-            self.release_channel(call_info["channel"])
-            print(f"[Twilio] {call_info['name']} hung up — channel {call_info['channel']} released")
-        self._websockets.pop(call_sid, None)
-
-    def reset(self):
-        with self._lock:
-            for call_info in self.active_calls.values():
-                self._allocated_channels.discard(call_info["channel"])
-            self._queue.clear()
-            self.active_calls.clear()
-            self._allocated_channels.clear()
-            self._caller_counter = 0
-            self._websockets.clear()
-        print("[Twilio] Service reset")
-
-    def register_websocket(self, call_sid: str, websocket):
-        """Register a WebSocket for a call"""
-        self._websockets[call_sid] = websocket
-
-    def unregister_websocket(self, call_sid: str):
-        """Unregister a WebSocket"""
-        self._websockets.pop(call_sid, None)
-
-    async def send_audio_to_caller(self, call_sid: str, pcm_data: bytes, sample_rate: int):
-        """Send audio back to real caller via Twilio WebSocket"""
-        ws = self._websockets.get(call_sid)
-        if not ws:
-            return
-
-        call_info = self.active_calls.get(call_sid)
-        if not call_info or "stream_sid" not in call_info:
-            return
-
-        try:
-            # Resample to 8kHz if needed
-            if sample_rate != 8000:
-                import numpy as np
-                import librosa
-                audio = np.frombuffer(pcm_data, dtype=np.int16).astype(np.float32) / 32768.0
-                audio = librosa.resample(audio, orig_sr=sample_rate, target_sr=8000)
-                pcm_data = (audio * 32767).astype(np.int16).tobytes()
-
-            # Convert PCM to mulaw
-            mulaw_data = audioop.lin2ulaw(pcm_data, 2)
-
-            # Send as Twilio media message
-            import json
-            await ws.send_text(json.dumps({
-                "event": "media",
-                "streamSid": call_info["stream_sid"],
-                "media": {
-                    "payload": base64.b64encode(mulaw_data).decode("ascii"),
-                },
-            }))
-        except Exception as e:
-            print(f"[Twilio] Failed to send audio to caller: {e}")