feat: add asterisk ARI websocket interface (#159)

* chore: remove old files

* feat: ari outbound dialing

* feat: add websocket configuration for ARI

* feat: handling inbound calls

* delete ext channel from redis on stasis end

* fix: add lock in workflow run update, refactor _handle_stasis_start

* chore: update submodule

---------

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

api/services/pipecat/audio_config.py

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

api/services/pipecat/run_pipeline.py

@@ -32,15 +32,14 @@ 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_ari_transport,
     create_cloudonix_transport,
-    create_stasis_transport,
     create_twilio_transport,
     create_vobiz_transport,
     create_vonage_transport,
     create_webrtc_transport,
 )
 from api.services.pipecat.ws_sender_registry import get_ws_sender
-from api.services.telephony.stasis_rtp_connection import StasisRTPConnection
 from api.services.workflow.dto import ReactFlowDTO
 from api.services.workflow.pipecat_engine import PipecatEngine
 from api.services.workflow.workflow import WorkflowGraph
@@ -199,6 +198,63 @@ async def run_pipeline_vonage(
         raise
 
 
+async def run_pipeline_ari(
+    websocket_client: WebSocket,
+    channel_id: str,
+    workflow_id: int,
+    workflow_run_id: int,
+    user_id: int,
+) -> None:
+    """Run pipeline for Asterisk ARI WebSocket connections.
+
+    ARI uses raw 16-bit signed linear PCM (SLIN16) at 16kHz
+    transmitted as binary WebSocket frames via chan_websocket.
+    """
+    logger.info(f"Starting ARI pipeline for workflow run {workflow_run_id}")
+    set_current_run_id(workflow_run_id)
+
+    # Store call ID (channel_id) in cost_info
+    cost_info = {"call_id": channel_id}
+    await db_client.update_workflow_run(workflow_run_id, cost_info=cost_info)
+
+    # Get workflow to extract 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"
+            ]
+
+    try:
+        audio_config = create_audio_config(WorkflowRunMode.ARI.value)
+
+        transport = await create_ari_transport(
+            websocket_client,
+            channel_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,
+        )
+
+    except Exception as e:
+        logger.error(f"Error in ARI pipeline: {e}")
+        raise
+
+
 async def run_pipeline_vobiz(
     websocket_client: WebSocket,
     stream_id: str,
@@ -364,52 +420,6 @@ async def run_pipeline_smallwebrtc(
     )
 
 
-async def run_pipeline_ari_stasis(
-    stasis_connection: StasisRTPConnection,
-    workflow_id: int,
-    workflow_run_id: int,
-    user_id: int,
-    call_context_vars: dict,
-) -> None:
-    """Run pipeline for ARI connections"""
-    logger.debug(
-        f"Running pipeline for ARI connection with workflow_id: {workflow_id} and workflow_run_id: {workflow_run_id}"
-    )
-    set_current_run_id(workflow_run_id)
-
-    # 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"
-            ]
-
-    # Create audio configuration for Stasis
-    audio_config = create_audio_config(WorkflowRunMode.STASIS.value)
-
-    transport = create_stasis_transport(
-        stasis_connection,
-        workflow_run_id,
-        audio_config,
-        vad_config,
-        ambient_noise_config,
-    )
-    await _run_pipeline(
-        transport,
-        workflow_id,
-        workflow_run_id,
-        user_id,
-        call_context_vars=call_context_vars,
-        audio_config=audio_config,
-        stasis_connection=stasis_connection,  # Pass connection for immediate transfers
-    )
-
-
 async def _run_pipeline(
     transport,
     workflow_id: int,
@@ -417,7 +427,6 @@ async def _run_pipeline(
     user_id: int,
     call_context_vars: dict = {},
     audio_config: AudioConfig = None,
-    stasis_connection: Optional[StasisRTPConnection] = None,
 ) -> None:
     """
     Run the pipeline with the given transport and configuration
@@ -559,10 +568,6 @@ async def _run_pipeline(
     engine.set_context(context)
     engine.set_audio_config(audio_config)
 
-    # Set Stasis connection for immediate transfers (if available)
-    if stasis_connection:
-        engine.set_stasis_connection(stasis_connection)
-
     assistant_params = LLMAssistantAggregatorParams(
         expect_stripped_words=True,
         correct_aggregation_callback=engine.create_aggregation_correction_callback(),

api/services/pipecat/service_factory.py

@@ -156,7 +156,7 @@ def create_tts_service(user_config, audio_config: "AudioConfig"):
 
     Args:
         user_config: User configuration containing TTS settings
-        transport_type: Type of transport (e.g., 'stasis', 'twilio', 'webrtc')
+        transport_type: Type of transport (e.g., 'twilio', 'webrtc')
     """
     logger.info(
         f"Creating TTS service: provider={user_config.tts.provider}, model={user_config.tts.model}"

api/services/pipecat/transport_setup.py

@@ -6,14 +6,9 @@ from api.constants import APP_ROOT_DIR
 from api.db import db_client
 from api.enums import OrganizationConfigurationKey
 from api.services.pipecat.audio_config import AudioConfig
-from api.services.telephony.stasis_rtp_connection import StasisRTPConnection
-from api.services.telephony.stasis_rtp_serializer import StasisRTPFrameSerializer
-from api.services.telephony.stasis_rtp_transport import (
-    StasisRTPTransport,
-    StasisRTPTransportParams,
-)
 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.twilio import TwilioFrameSerializer
 from pipecat.serializers.vobiz import VobizFrameSerializer
 from pipecat.serializers.vonage import VonageFrameSerializer
@@ -156,6 +151,70 @@ async def create_cloudonix_transport(
     )
 
 
+async def create_ari_transport(
+    websocket_client: WebSocket,
+    channel_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 Asterisk ARI connections"""
+
+    from api.services.telephony.factory import load_telephony_config
+
+    config = await load_telephony_config(organization_id)
+
+    if config.get("provider") != "ari":
+        raise ValueError(f"Expected ARI provider, got {config.get('provider')}")
+
+    ari_endpoint = config.get("ari_endpoint")
+    app_name = config.get("app_name")
+    app_password = config.get("app_password")
+
+    if not ari_endpoint or not app_name or not app_password:
+        raise ValueError(
+            f"Incomplete ARI configuration for organization {organization_id}. "
+            f"Required: ari_endpoint, app_name, app_password"
+        )
+
+    serializer = AsteriskFrameSerializer(
+        channel_id=channel_id,
+        ari_endpoint=ari_endpoint,
+        app_name=app_name,
+        app_password=app_password,
+        params=AsteriskFrameSerializer.InputParams(
+            asterisk_sample_rate=audio_config.transport_in_sample_rate,
+            sample_rate=audio_config.pipeline_sample_rate,
+        ),
+    )
+
+    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_vonage_transport(
     websocket_client,
     call_uuid: str,
@@ -345,47 +404,6 @@ def create_webrtc_transport(
     )
 
 
-def create_stasis_transport(
-    stasis_connection: StasisRTPConnection,
-    workflow_run_id: int,
-    audio_config: AudioConfig,
-    vad_config: dict | None = None,
-    ambient_noise_config: dict | None = None,
-):
-    """Create a transport for ARI connections"""
-
-    serializer = StasisRTPFrameSerializer(
-        StasisRTPFrameSerializer.InputParams(
-            sample_rate=audio_config.transport_in_sample_rate
-        )
-    )
-
-    return StasisRTPTransport(
-        stasis_connection,
-        params=StasisRTPTransportParams(
-            audio_in_enabled=True,
-            audio_out_enabled=True,
-            audio_out_sample_rate=audio_config.transport_out_sample_rate,
-            audio_in_sample_rate=audio_config.transport_in_sample_rate,
-            # audio_out_10ms_chunks=2,  # ToDo: Check if we cant support 40 ms packets?
-            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,
-        ),
-    )
-
-
 def create_internal_transport(
     workflow_run_id: int,
     audio_config: AudioConfig,