feat: add cloudonix outbound telephony (#101)

Co-authored-by: Sabiha Khan <sabihak89@gmail.com>

api/services/pipecat/audio_config.py

@@ -87,7 +87,7 @@ def create_audio_config(transport_type: str) -> AudioConfig:
     """Create audio configuration based on transport type.
 
     Args:
-        transport_type: Type of transport ("webrtc", "twilio", "vonage", "stasis")
+        transport_type: Type of transport ("webrtc", "twilio", "vonage", "vobiz", "cloudonix", "stasis")
 
     Returns:
         AudioConfig instance with appropriate settings
@@ -96,8 +96,9 @@ def create_audio_config(transport_type: str) -> AudioConfig:
         WorkflowRunMode.STASIS.value,
         WorkflowRunMode.TWILIO.value,
         WorkflowRunMode.VOBIZ.value,
+        WorkflowRunMode.CLOUDONIX.value,
     ):
-        # Twilio, Vobiz, and Stasis use MULAW at 8kHz
+        # Twilio, Cloudonix, Vobiz, and Stasis use MULAW at 8kHz
         return AudioConfig(
             transport_in_sample_rate=8000,
             transport_out_sample_rate=8000,

api/services/pipecat/run_pipeline.py

@@ -30,6 +30,7 @@ from api.services.pipecat.service_factory import (
 )
 from api.services.pipecat.tracing_config import setup_pipeline_tracing
 from api.services.pipecat.transport_setup import (
+    create_cloudonix_transport,
     create_stasis_transport,
     create_twilio_transport,
     create_vobiz_transport,
@@ -240,6 +241,66 @@ async def run_pipeline_vobiz(
         raise
 
 
+async def run_pipeline_cloudonix(
+    websocket_client: WebSocket,
+    stream_sid: str,
+    call_sid: str,
+    workflow_id: int,
+    workflow_run_id: int,
+    user_id: int,
+) -> None:
+    """Run pipeline for Cloudonix connections"""
+    logger.debug(
+        f"Running pipeline for Cloudonix connection with workflow_id: {workflow_id} and workflow_run_id: {workflow_run_id}"
+    )
+    set_current_run_id(workflow_run_id)
+
+    # Store call ID in cost_info for later cost calculation (provider-agnostic)
+    cost_info = {"call_id": call_sid}
+    await db_client.update_workflow_run(workflow_run_id, cost_info=cost_info)
+
+    # Get workflow to extract all pipeline configurations
+    workflow = await db_client.get_workflow(workflow_id, user_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"
+            ]
+
+    # Retrieve session_token from workflow_run gathered_context
+    workflow_run = await db_client.get_workflow_run(workflow_run_id)
+    session_token = None
+    if workflow_run and workflow_run.gathered_context:
+        session_token = workflow_run.gathered_context.get("session_token")
+        logger.debug(f"Retrieved session_token from workflow_run: {session_token}")
+
+    # Create audio configuration for Cloudonix
+    audio_config = create_audio_config(WorkflowRunMode.CLOUDONIX.value)
+
+    transport = await create_cloudonix_transport(
+        websocket_client,
+        stream_sid,
+        call_sid,
+        workflow_run_id,
+        audio_config,
+        workflow.organization_id,
+        vad_config,
+        ambient_noise_config,
+        session_token,
+    )
+    await _run_pipeline(
+        transport,
+        workflow_id,
+        workflow_run_id,
+        user_id,
+        audio_config=audio_config,
+    )
+
+
 async def run_pipeline_smallwebrtc(
     webrtc_connection: SmallWebRTCConnection,
     workflow_id: int,

api/services/pipecat/transport_setup.py

@@ -127,6 +127,88 @@ async def create_twilio_transport(
         ),
     )
 
+async def create_cloudonix_transport(
+    websocket_client: WebSocket,
+    stream_sid: str,
+    call_sid: str,
+    workflow_run_id: int,
+    audio_config: AudioConfig,
+    organization_id: int,
+    vad_config: dict | None = None,
+    ambient_noise_config: dict | None = None,
+    session_token: str | None = None,
+):
+    """Create a transport for Cloudonix connections"""
+
+    # Load Cloudonix configuration from database
+    from api.services.telephony.factory import load_telephony_config
+
+    config = await load_telephony_config(organization_id)
+
+    if config.get("provider") != "cloudonix":
+        raise ValueError(f"Expected Cloudonix provider, got {config.get('provider')}")
+
+    bearer_token = config.get("bearer_token")
+    domain_id = config.get("domain_id")
+
+    if not bearer_token or not domain_id:
+        raise ValueError(
+            f"Incomplete Cloudonix configuration for organization {organization_id}. "
+            f"Required: bearer_token, domain_id"
+        )
+
+    turn_analyzer = create_turn_analyzer(workflow_run_id, audio_config)
+
+    from pipecat.serializers.cloudonix import CloudonixFrameSerializer
+
+    serializer = CloudonixFrameSerializer(
+        stream_sid=stream_sid,
+        call_sid=call_sid,
+        domain_id=domain_id,
+        bearer_token=bearer_token,
+        session_token=session_token,
+    )
+
+    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,
+            vad_analyzer=(
+                SileroVADAnalyzer(
+                    params=VADParams(
+                        confidence=vad_config.get("confidence", 0.7),
+                        start_secs=vad_config.get("start_seconds", 0.4),
+                        stop_secs=vad_config.get("stop_seconds", 0.8),
+                        min_volume=vad_config.get("minimum_volume", 0.6),
+                    )
+                )
+                if vad_config
+                else SileroVADAnalyzer()
+            ),  # Sample rate will be set by transport
+            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()
+            ),
+            turn_analyzer=turn_analyzer,
+            serializer=serializer,
+            audio_in_filter=RNNoiseFilter(library_path=librnnoise_path)
+            if ENABLE_RNNOISE
+            else None,
+        ),
+    )    
+
 
 async def create_vonage_transport(
     websocket_client,