Wrap text in color codes.

Get a connected TTS service with the given callbacks. Returns a warm connection if available (and not stale), otherwise bloc

Pure state machine: (State, Event) -> (State, Actions) With Flux, this is just a simple router: - MediaEvent -> feed audio to Flu

Log an error (red).

Cancel ongoing generation.

White outline effect for text readability over the map.

Milliseconds elapsed since t0.

Begin a named span.

End a named span.

Get a logger instance.

Cancel current turn, preserve history.

Send text chunk for synthesis.

Stop playback immediately and clear Twilio's buffer.

Clean up resources.

Clean up resources.

Independent loop that drips audio at ~20ms intervals.

Wrap text in quotes with color.

Signal the fill loop to check pool levels.

Force synthesis of any buffered text.

Initiate an outbound call using Twilio. Args: to_number: Phone number to call in E.164 format (+1234567890) Returns

Record a point-in-time marker.

Start generating a response.

Open WebSocket connection to ElevenLabs.

Remove connections that have been idle past TTL.

Background loop that keeps the pool at target size.

Generate response and stream tokens.

Parse and handle ElevenLabs response.

Build provider → AsyncOpenAI client map.

Single TTFT measurement in milliseconds. Opens a streaming completion, records time-to-first-content-token, then closes the stream immed

Background task to receive audio chunks.

Render a single turn on one subplot.

Send a single audio chunk to Twilio.

Send clear message to Twilio to flush audio buffer.

Truncate long call IDs for display.

Log an outgoing action.

Start a new turn, returns turn number.

Rebind callbacks (used by connection pool to assign per-turn handlers).

Abort connection immediately.

Check that all required environment variables are set.

Final cleanup when call ends.

Log an incoming event.

Fetch trace JSON from a remote URL.

Main entry point.

CLI entry point.

Signal that TTS is complete - no more chunks coming.

Parse raw Twilio WebSocket message into typed Event.

Background task to read from Twilio and push to event queue.

Render a trace as a Gantt chart.

Main event loop for a single call. 1. Create shared event queue 2. Create Flux service (always-on STT + turn detection) 3. Start Twi

Write trace data to /tmp/shuo/<call_id>.json.

Send audio chunk to Deepgram Flux.

Add an audio chunk to the playback queue.

Configure logging for the application.

Start the playback loop.

Start the pool and begin pre-connecting.

Connect to Deepgram Flux (always-on for the duration of the call).

Start a new agent turn.

Shut down pool and clean up all connections.

Disconnect from Deepgram Flux.

Log a phase transition (magenta).

Format axis tick as integer ms or seconds.

Railway (and Docker) send SIGTERM before killing the container. We stop accepting new calls and wait for active ones to finish.

Handle Deepgram errors.

LLM finished -> flush TTS.

LLM produced a token -> feed to TTS.

Handle Flux messages -- parse TurnInfo events.

Player finished -> turn is complete.

TTS produced audio -> send to player.

TTS finished -> tell player no more chunks coming.

Number of warm connections ready to dispense.

Benchmark TTFT across OpenAI-compatible models. Usage: curl https://your-server/bench/ttft curl https://your-server/bench/tt

Mark turn as cancelled and end all open spans at current time.