Daily WebRTC Transport

uv add "pipecat-ai[daily]"

from pipecat.frames.frames import TTSSpeakFrame
from pipecat.transports.daily.transport import DailySIPTransferFrame

goodbye = TTSSpeakFrame("Transferring you to our billing team now.")
transfer = DailySIPTransferFrame(settings={"toEndPoint": "+15551234567"})
# Otherwise the caller talking over the goodbye drops the transfer
goodbye.interruptible = False
transfer.interruptible = False

await worker.queue_frames([goodbye, transfer])

async def capture_participant_transcription(participant_id: str)

async def capture_participant_audio(
    participant_id: str,
    audio_source: str = "microphone",
    sample_rate: int = 16000,
)

async def capture_participant_video(
    participant_id: str,
    framerate: int | None = 30,
    video_source: str = "camera",
    color_format: str = "RGB",
    *,
    on_request_only: bool = False,
)

async def start_dialout(
    settings: Mapping[str, Any] | None = None,
) -> tuple[str, str | None]

async def stop_dialout(participant_id: str) -> str | None

async def start_recording(
    streaming_settings: Mapping[str, Any] | None = None,
    stream_id: str | None = None,
    force_new: bool | None = None,
) -> tuple[str, str | None]

@transport.event_handler("on_first_participant_joined")
async def on_first_participant_joined(transport, participant):
    stream_id, error = await transport.start_recording()
    if error:
        logger.error(f"Failed to start recording: {error}")

from pipecat.transports.daily.utils import (
    DailyMeetingTokenParams,
    DailyMeetingTokenProperties,
)

token = await helper.get_token(
    room_url="https://your-domain.daily.co/my-room",
    params=DailyMeetingTokenParams(
        properties=DailyMeetingTokenProperties(
            enable_recording="cloud",
            start_cloud_recording=True,
        )
    ),
)

async def stop_recording(stream_id: str | None = None) -> str | None

async def update_publishing(publishing_settings: Mapping[str, Any]) -> str | None

def participants() -> Mapping[str, Any]

from pipecat.transports.daily.transport import (
    DailyTransport,
    DailyParams,
    DailyTranscriptionSettings,
)

transport = DailyTransport(
    room_url,
    token,
    "Voice Bot",
    DailyParams(
        audio_in_enabled=True,
        audio_out_enabled=True,
        transcription_enabled=True,
        transcription_settings=DailyTranscriptionSettings(
            language="en",
            model="nova-3-general",
        ),
    ),
)

@transport.event_handler("on_first_participant_joined")
async def on_first_participant_joined(transport, participant):
    await transport.capture_participant_transcription(participant["id"])

params = DailyParams(
    audio_out_enabled=True,
    audio_out_destinations=["screenAudio"]
)

# Route frames to the screen audio track
frame = OutputAudioRawFrame(...)
frame.transport_destination = "screenAudio"

params = DailyParams(
    audio_out_enabled=True,
    audio_out_destinations=["screenAudio"],
    custom_audio_track_params={
        "screenAudio": DailyCustomAudioTrackParams(
            sample_rate=48000,
            channels=2,
            send_settings={"maxBitrate": 128000}
        )
    }
)

params = DailyParams(
    video_out_enabled=True,
    video_out_is_live=True,
    video_out_width=1280,
    video_out_height=720,
    video_out_destinations=["screenVideo"]
)

# Route frames to the screen video track
frame = OutputImageRawFrame(...)
frame.transport_destination = "screenVideo"

params = DailyParams(
    camera_out_send_settings={
        "maxQuality": "high",
        "encodings": {
            "high": {"maxBitrate": 2_000_000, "maxFramerate": 30}
        },
    },
)

@transport.event_handler("on_joined")
async def on_joined(transport, data):
    print(f"Bot joined the room: {data}")

@transport.event_handler("on_connected")
async def on_connected(transport, data):
    print(f"Bot connected to the room: {data}")

@transport.event_handler("on_left")
async def on_left(transport):
    print("Bot left the room")

@transport.event_handler("on_before_leave")
async def on_before_leave(transport):
    print("About to leave the room...")

@transport.event_handler("on_error")
async def on_error(transport, error):
    print(f"Transport error: {error}")

@transport.event_handler("on_call_state_updated")
async def on_call_state_updated(transport, state):
    print(f"Call state: {state}")

@transport.event_handler("on_network_connection_status_updated")
async def on_network_connection_status_updated(transport, status):
    print(f"{status['connection']}: {status['event']}")

@transport.event_handler("on_first_participant_joined")
async def on_first_participant_joined(transport, participant):
    await worker.queue_frame(TTSSpeakFrame("Hello! How can I help you today?"))

@transport.event_handler("on_participant_joined")
async def on_participant_joined(transport, participant):
    print(f"Participant joined: {participant['id']}")

@transport.event_handler("on_participant_left")
async def on_participant_left(transport, participant, reason):
    print(f"Participant {participant['id']} left: {reason}")

@transport.event_handler("on_participant_updated")
async def on_participant_updated(transport, participant):
    print(f"Participant updated: {participant['id']}")

@transport.event_handler("on_client_connected")
async def on_client_connected(transport, participant):
    print(f"Client connected: {participant['id']}")

@transport.event_handler("on_active_speaker_changed")
async def on_active_speaker_changed(transport, participant):
    print(f"Active speaker: {participant['id']}")

@transport.event_handler("on_app_message")
async def on_app_message(transport, message, sender):
    print(f"Message from {sender}: {message}")

@transport.event_handler("on_transcription_message")
async def on_transcription_message(transport, message):
    print(f"Transcription: {message['text']}")

@transport.event_handler("on_transcription_stopped")
async def on_transcription_stopped(transport, stopped_by, stopped_by_error):
    print(f"Transcription stopped by {stopped_by} (error: {stopped_by_error})")

@transport.event_handler("on_transcription_error")
async def on_transcription_error(transport, message):
    print(f"Transcription error: {message}")

@transport.event_handler("on_recording_started")
async def on_recording_started(transport, status):
    print(f"Recording started: {status}")

@transport.event_handler("on_recording_error")
async def on_recording_error(transport, stream_id, message):
    print(f"Recording error for {stream_id}: {message}")

@transport.event_handler("on_dialin_ready")
async def on_dialin_ready(transport, sip_endpoint):
    print(f"Dial-in ready at: {sip_endpoint}")

@transport.event_handler("on_dialin_connected")
async def on_dialin_connected(transport, data):
    print(f"Dial-in connected: {data}")

@transport.event_handler("on_dialin_error")
async def on_dialin_error(transport, data):
    print(f"Dial-in error: {data}")

@transport.event_handler("on_dialout_answered")
async def on_dialout_answered(transport, data):
    print(f"Dial-out answered: {data}")

@transport.event_handler("on_dialout_error")
async def on_dialout_error(transport, data):
    print(f"Dial-out error: {data}")

@transport.event_handler("on_dtmf_event")
async def on_dtmf_event(transport, data):
    tone = data["tone"]
    print(f"Received DTMF tone: {tone}")