feat: integrate Telnyx telephony for outbound and inbound calling (#206)

* feat: integrate Telnyx telephony for outbound and inbound calling

* chore: remove redundant code

---------

Co-authored-by: Abhishek <abhishek@a6k.me>

api/services/pipecat/audio_config.py

@@ -97,8 +97,9 @@ def create_audio_config(transport_type: str) -> AudioConfig:
         WorkflowRunMode.VOBIZ.value,
         WorkflowRunMode.CLOUDONIX.value,
         WorkflowRunMode.ARI.value,
+        WorkflowRunMode.TELNYX.value,
     ):
-        # Twilio, Cloudonix, Vobiz, and ARI use MULAW at 8kHz
+        # Twilio, Cloudonix, Vobiz, Telnyx, and ARI use MULAW at 8kHz
         return AudioConfig(
             transport_in_sample_rate=8000,
             transport_out_sample_rate=8000,

api/services/pipecat/run_pipeline.py

@@ -44,6 +44,7 @@ from api.services.pipecat.tracing_config import (
 from api.services.pipecat.transport_setup import (
     create_ari_transport,
     create_cloudonix_transport,
+    create_telnyx_transport,
     create_twilio_transport,
     create_vobiz_transport,
     create_vonage_transport,
@@ -344,6 +345,74 @@ async def run_pipeline_vobiz(
         raise
 
 
+async def run_pipeline_telnyx(
+    websocket_client: WebSocket,
+    stream_id: str,
+    call_control_id: str,
+    workflow_id: int,
+    workflow_run_id: int,
+    user_id: int,
+) -> None:
+    """Run pipeline for Telnyx Call Control WebSocket connections.
+
+    Telnyx uses PCMU at 8kHz over WebSocket with base64-encoded media events,
+    similar to Twilio's protocol.
+    """
+    logger.info(
+        f"[run {workflow_run_id}] Starting Telnyx pipeline - "
+        f"stream_id={stream_id}, call_control_id={call_control_id}, "
+        f"workflow_id={workflow_id}"
+    )
+    set_current_run_id(workflow_run_id)
+
+    cost_info = {"call_id": call_control_id}
+    await db_client.update_workflow_run(workflow_run_id, cost_info=cost_info)
+
+    workflow = await db_client.get_workflow(workflow_id, user_id)
+
+    if workflow:
+        set_current_org_id(workflow.organization_id)
+
+    vad_config = None
+    ambient_noise_config = None
+    if workflow and workflow.workflow_configurations:
+        if "vad_configuration" in workflow.workflow_configurations:
+            vad_config = workflow.workflow_configurations["vad_configuration"]
+        if "ambient_noise_configuration" in workflow.workflow_configurations:
+            ambient_noise_config = workflow.workflow_configurations[
+                "ambient_noise_configuration"
+            ]
+
+    try:
+        audio_config = create_audio_config(WorkflowRunMode.TELNYX.value)
+
+        transport = await create_telnyx_transport(
+            websocket_client,
+            stream_id,
+            call_control_id,
+            workflow_run_id,
+            audio_config,
+            workflow.organization_id,
+            vad_config,
+            ambient_noise_config,
+        )
+
+        await _run_pipeline(
+            transport,
+            workflow_id,
+            workflow_run_id,
+            user_id,
+            audio_config=audio_config,
+        )
+        logger.info(f"[run {workflow_run_id}] Telnyx pipeline completed successfully")
+
+    except Exception as e:
+        logger.error(
+            f"[run {workflow_run_id}] Error in Telnyx pipeline: {e}", exc_info=True
+        )
+        raise
+
+
 async def run_pipeline_cloudonix(
     websocket_client: WebSocket,
     stream_sid: str,

api/services/pipecat/transport_setup.py

@@ -20,6 +20,7 @@ from api.services.telephony.providers.twilio_call_strategies import (
 from pipecat.audio.mixers.silence_mixer import SilenceAudioMixer
 from pipecat.audio.mixers.soundfile_mixer import SoundfileMixer
 from pipecat.serializers.asterisk import AsteriskFrameSerializer
+from pipecat.serializers.telnyx import TelnyxFrameSerializer
 from pipecat.serializers.twilio import TwilioFrameSerializer
 from pipecat.serializers.vobiz import VobizFrameSerializer
 from pipecat.serializers.vonage import VonageFrameSerializer
@@ -169,6 +170,70 @@ async def create_cloudonix_transport(
     )
 
 
+async def create_telnyx_transport(
+    websocket_client: WebSocket,
+    stream_id: str,
+    call_control_id: str,
+    workflow_run_id: int,
+    audio_config: AudioConfig,
+    organization_id: int,
+    vad_config: dict | None = None,
+    ambient_noise_config: dict | None = None,
+):
+    """Create a transport for Telnyx connections."""
+    config = await db_client.get_configuration(
+        organization_id, OrganizationConfigurationKey.TELEPHONY_CONFIGURATION.value
+    )
+
+    if not config or not config.value:
+        raise ValueError(
+            f"Telnyx credentials not configured for organization {organization_id}"
+        )
+
+    if config.value.get("provider") != "telnyx":
+        raise ValueError(
+            f"Expected Telnyx provider, got {config.value.get('provider')}"
+        )
+
+    api_key = config.value.get("api_key")
+    if not api_key:
+        raise ValueError(
+            f"Incomplete Telnyx configuration for organization {organization_id}"
+        )
+
+    serializer = TelnyxFrameSerializer(
+        stream_id=stream_id,
+        call_control_id=call_control_id,
+        api_key=api_key,
+        outbound_encoding="PCMU",
+        inbound_encoding="PCMU",
+    )
+
+    return FastAPIWebsocketTransport(
+        websocket=websocket_client,
+        params=FastAPIWebsocketParams(
+            audio_in_enabled=True,
+            audio_out_enabled=True,
+            audio_in_sample_rate=audio_config.transport_in_sample_rate,
+            audio_out_sample_rate=audio_config.transport_out_sample_rate,
+            audio_out_mixer=(
+                SoundfileMixer(
+                    sound_files={
+                        "office": APP_ROOT_DIR
+                        / "assets"
+                        / f"office-ambience-{audio_config.transport_out_sample_rate}-mono.wav"
+                    },
+                    default_sound="office",
+                    volume=ambient_noise_config.get("volume", 0.3),
+                )
+                if ambient_noise_config and ambient_noise_config.get("enabled", False)
+                else SilenceAudioMixer()
+            ),
+            serializer=serializer,
+        ),
+    )
+
+
 async def create_ari_transport(
     websocket_client: WebSocket,
     channel_id: str,