POST https://api.goto.com/web-calls/v1/calls
{
  "deviceId": "1234567809012111116",
  "organizationId": "INTEGRATOR_ORG_ID",
  "extensionNumber": "0523",
  "dialString": "+13142797222",
  "inCallChannelId": "Webhook.6050752e-78dd-47af-8e22-552d3d6e3326",
  "sdp": "v=0\r\no=- 1383702073071536301 0 IN IP4 0.0.0.0\r\n..."
}

POST https://api.goto.com/notification-channel/v1/channels/demo
{"channelType": "WebSocket"}

from livekit import agents
from livekit.agents import AgentSession, Agent, RoomInputOptions
from livekit.plugins import openai, deepgram, cartesia

async def entrypoint(ctx: agents.JobContext):
    await ctx.connect()
    session = AgentSession(
        stt=deepgram.STT(model="nova-3", endpointing_ms=3000),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=cartesia.TTS(model="sonic-2")
    )
    await session.start(
        room=ctx.room,
        agent=Agent(instructions="You are a helpful voice AI assistant.")
    )

stt = deepgram.STT(
    model="nova-3",
    language="en-US",
    sample_rate=16000,
    endpointing_ms=3000,
    interim_results=True,
    punctuate=True
)

from livekit.agents.tts import TTS, SynthesizeStream

class CustomTTS(TTS):
    async def synthesize(self, text: str) -> AsyncIterator[SynthesizedAudio]:
        # Custom synthesis logic
        pass
    
    def stream(self) -> SynthesizeStream:
        # Return streaming interface
        pass

from livekit.plugins.turn_detector import MultilingualModel

session = AgentSession(
    turn_detection=MultilingualModel(),
    allow_interruptions=True,
    min_interruption_duration=0.5,  # seconds
    min_endpointing_delay=0.5       # minimum silence for turn end
)

{
  "trunk": {
    "name": "production-inbound",
    "numbers": ["+15105550100"],
    "krisp_enabled": true
  }
}

{
  "trunk": {
    "name": "production-outbound",
    "address": "sip.telnyx.com",
    "numbers": ["+15105550100"],
    "auth_username": "your_username",
    "auth_password": "your_password"
  }
}

{
  "rule": {
    "dispatchRuleIndividual": {
      "roomPrefix": "call-"
    }
  },
  "trunk_ids": ["trunk-id"]
}

from livekit import api

sip_participant = await api.sip.create_sip_participant(
    api.CreateSIPParticipantRequest(
        sip_trunk_id="trunk-id",
        sip_call_to="+12135550100",
        room_name="outbound-room",
        participant_identity="ai-agent"
    )
)

from aiortc import RTCPeerConnection, RTCSessionDescription

async def handle_gotoconnect_offer(sdp_offer: str):
    pc = RTCPeerConnection()
    
    @pc.on("track")
    def on_track(track):
        if track.kind == "audio":
            asyncio.create_task(bridge_to_livekit(track))
    
    offer = RTCSessionDescription(sdp=sdp_offer, type="offer")
    await pc.setRemoteDescription(offer)
    answer = await pc.createAnswer()
    await pc.setLocalDescription(answer)
    return pc.localDescription.sdp

from livekit import rtc

async def bridge_to_livekit(gotoconnect_track):
    # Connect to LiveKit room
    room = rtc.Room()
    await room.connect(livekit_url, token)
    
    # Create audio source at 48kHz (matches GoToConnect Opus)
    source = rtc.AudioSource(sample_rate=48000, num_channels=1)
    track = rtc.LocalAudioTrack.create_audio_track("sip-audio", source)
    await room.local_participant.publish_track(track)
    
    # Forward frames
    while True:
        frame = await gotoconnect_track.recv()
        lk_frame = rtc.AudioFrame(
            data=frame.to_ndarray().tobytes(),
            sample_rate=48000,
            num_channels=1,
            samples_per_channel=960  # 20ms at 48kHz
        )
        await source.capture_frame(lk_frame)

from livekit.plugins import cartesia

tts = cartesia.TTS(
    model="sonic-3",
    voice="95856005-0332-41b0-935f-352e296aa0df",
    language="en",
    speed=1.0
)

from chatterbox.tts_turbo import ChatterboxTurboTTS

model = ChatterboxTurboTTS.from_pretrained(device="cuda")
wav = model.generate(
    text="[laugh] How can I help you today?",
    audio_prompt_path="voice_sample.wav"  # 5-10s for cloning
)

PSTN → SIP Provider (Twilio/Telnyx) → LiveKit SIP Service → 
LiveKit Room → Agent Session → STT (Deepgram) → 
LLM (GPT-4o-mini) → TTS (Cartesia) → LiveKit Room → 
SIP Service → PSTN

# Add human agent to existing room
await api.room.update_participant(
    api.UpdateParticipantRequest(
        room=call_room,
        identity="human-agent",
        metadata='{"role":"supervisor"}'
    )
)
# AI provides context briefing, then disconnects
await session.say("I'm connecting you with a specialist who has your account details.")

# Transfer call to agent extension
await api.sip.transfer_sip_participant(
    api.TransferSIPParticipantRequest(
        room_name="call-room",
        participant_identity="caller",
        transfer_to="sip:agent@pbx.example.com"
    )
)

from livekit.agents import function_tool

@function_tool
async def lookup_account(run_ctx: RunContext, account_number: str):
    """Look up customer account information"""
    # Executes while conversation continues
    result = await crm_api.get_account(account_number)
    return f"Account holder: {result.name}, balance: ${result.balance}"

session = AgentSession(
    tools=[lookup_account],
    # ...
)

PSTN ← → Twilio/Telnyx SIP Trunk ← → LiveKit SIP Service
                                           ↓
                                    LiveKit Room
                                           ↓
                                    Agent Session
                                    (STT + LLM + TTS)
                                           ↓
                            Human Handoff via SIP REFER