Pipecat Agent with TeleQuick Transport

# ILLUSTRATIVE glue you write today — wraps the REAL audio bridge for Pipecat.
from pipecat.frames.frames import InputAudioRawFrame, OutputAudioRawFrame
from pipecat.processors.frame_processor import FrameProcessor

class MoqtBridgeInput(FrameProcessor):
    """Emits caller uplink audio as Pipecat input frames."""
    def __init__(self, sample_rate: int = 16000):
        super().__init__()
        self.sample_rate = sample_rate

    def on_uplink(self, pcm: bytes, ts_us: int):
        frame = InputAudioRawFrame(audio=pcm, sample_rate=self.sample_rate, num_channels=1)
        # hand the frame downstream into the pipeline
        self.push_frame(frame)

class MoqtBridgeOutput(FrameProcessor):
    """Publishes agent output frames back as downlink audio."""
    def __init__(self, bridge):
        super().__init__()
        self.bridge = bridge

    async def process_frame(self, frame, direction):
        await super().process_frame(frame, direction)
        if isinstance(frame, OutputAudioRawFrame):
            self.bridge.publish_downlink(frame.audio)   # bot -> caller (SDK, real)
        await self.push_frame(frame, direction)

# ILLUSTRATIVE — a standard Pipecat pipeline between the two bridge wrappers.
from pipecat.pipeline.pipeline import Pipeline
from pipecat.pipeline.runner import PipelineRunner
from pipecat.pipeline.task import PipelineTask

bridge_in  = MoqtBridgeInput(sample_rate=16000)
bridge_out = MoqtBridgeOutput(bridge)

# route the SDK's uplink callback into the input processor
# (v.audio_bridge.attach(..., on_uplink=bridge_in.on_uplink))

pipeline = Pipeline([
    bridge_in,     # caller audio in
    stt,           # your ASR frame processor
    llm,           # your LLM context
    tts,           # your TTS frame processor
    bridge_out,    # agent audio back to the caller
])