fixup

Added cartesia line to CHANGELOG.md

.github/workflows/publish_test.yaml

@@ -40,7 +40,7 @@ jobs:
           name: wheels
           path: ./dist
 
-  publish-to-pypi:
+  publish-to-test-pypi:
     name: "Publish to Test PyPI"
     runs-on: ubuntu-latest
     needs: [ build ]

CHANGELOG.md

@@ -5,6 +5,177 @@ All notable changes to **pipecat** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- Added Cartesia TTS support (https://cartesia.ai/)
+
+### Fixed
+
+- Fixed SileroVAD frame processor.
+
+- Fixed an issue where `camera_out_enabled` would cause the highg CPU usage if
+  no image was provided.
+
+
+## [0.0.24] - 2024-05-29
+
+### Added
+
+- Exposed `on_dialin_ready` for Daily transport SIP endpoint handling. This
+  notifies when the Daily room SIP endpoints are ready. This allows integrating
+  with third-party services like Twilio.
+
+- Exposed Daily transport `on_app_message` event.
+
+- Added Daily transport `on_call_state_updated` event.
+
+- Added Daily transport `start_recording()`, `stop_recording` and
+  `stop_dialout`.
+
+### Changed
+
+- Added `PipelineParams`. This replaces the `allow_interruptions` argument in
+  `PipelineTask` and will allow future parameters in the future.
+
+- Fixed Deepgram Aura TTS base_url and added ErrorFrame reporting.
+
+- GoogleLLMService `api_key` argument is now mandatory.
+
+### Fixed
+
+- Daily tranport `dialin-ready` doesn't not block anymore and it now handles
+  timeouts.
+
+- Fixed AzureLLMService.
+
+## [0.0.23] - 2024-05-23
+
+### Fixed
+
+- Fixed an issue handling Daily transport `dialin-ready` event.
+
+## [0.0.22] - 2024-05-23
+
+### Added
+
+- Added Daily transport `start_dialout()` to be able to make phone or SIP calls.
+  See https://reference-python.daily.co/api_reference.html#daily.CallClient.start_dialout
+
+- Added Daily transport support for dial-in use cases.
+
+- Added Daily transport events: `on_dialout_connected`, `on_dialout_stopped`,
+  `on_dialout_error` and `on_dialout_warning`.  See
+  https://reference-python.daily.co/api_reference.html#daily.EventHandler
+
+## [0.0.21] - 2024-05-22
+
+### Added
+
+- Added vision support to Anthropic service.
+
+- Added `WakeCheckFilter` which allows you to pass information downstream only
+  if you say a certain phrase/word.
+
+### Changed
+
+- `Filter` has been renamed to `FrameFilter` and it's now under
+  `processors/filters`.
+
+### Fixed
+
+- Fixed Anthropic service to use new frame types.
+
+- Fixed an issue in `LLMUserResponseAggregator` and `UserResponseAggregator`
+  that would cause frames after a brief pause to not be pushed to the LLM.
+
+- Clear the audio output buffer if we are interrupted.
+
+- Re-add exponential smoothing after volume calculation. This makes sure the
+  volume value being used doesn't fluctuate so much.
+
+## [0.0.20] - 2024-05-22
+
+### Added
+
+- In order to improve interruptions we now compute a loudness level using
+  [pyloudnorm](https://github.com/csteinmetz1/pyloudnorm). The audio coming
+  WebRTC transports (e.g. Daily) have an Automatic Gain Control (AGC) algorithm
+  applied to the signal, however we don't do that on our local PyAudio
+  signals. This means that currently incoming audio from PyAudio is kind of
+  broken. We will fix it in future releases.
+
+### Fixed
+
+- Fixed an issue where `StartInterruptionFrame` would cause
+  `LLMUserResponseAggregator` to push the accumulated text causing the LLM
+  respond in the wrong task. The `StartInterruptionFrame` should not trigger any
+  new LLM response because that would be spoken in a different task.
+
+- Fixed an issue where tasks and threads could be paused because the executor
+  didn't have more tasks available. This was causing issues when cancelling and
+  recreating tasks during interruptions.
+
+## [0.0.19] - 2024-05-20
+
+### Changed
+
+- `LLMUserResponseAggregator` and `LLMAssistantResponseAggregator` internal
+  messages are now exposed through the `messages` property.
+
+### Fixed
+
+- Fixed an issue where `LLMAssistantResponseAggregator` was not accumulating the
+  full response but short sentences instead. If there's an interruption we only
+  accumulate what the bot has spoken until now in a long response as well.
+
+## [0.0.18] - 2024-05-20
+
+### Fixed
+
+- Fixed an issue in `DailyOuputTransport` where transport messages were not
+  being sent.
+
+## [0.0.17] - 2024-05-19
+
+### Added
+
+- Added `google.generativeai` model support, including vision. This new `google`
+  service defaults to using `gemini-1.5-flash-latest`. Example in
+  `examples/foundational/12a-describe-video-gemini-flash.py`.
+
+- Added vision support to `openai` service. Example in
+  `examples/foundational/12a-describe-video-gemini-flash.py`.
+
+- Added initial interruptions support. The assistant contexts (or aggregators)
+  should now be placed after the output transport. This way, only the completed
+  spoken context is added to the assistant context.
+
+- Added `VADParams` so you can control voice confidence level and others.
+
+- `VADAnalyzer` now uses an exponential smoothed volume to improve speech
+  detection. This is useful when voice confidence is high (because there's
+  someone talking near you) but volume is low.
+
+### Fixed
+
+- Fixed an issue where TTSService was not pushing TextFrames downstream.
+
+- Fixed issues with Ctrl-C program termination.
+
+- Fixed an issue that was causing `StopTaskFrame` to actually not exit the
+  `PipelineTask`.
+
+## [0.0.16] - 2024-05-16
+
+### Fixed
+
+- `DailyTransport`: don't publish camera and audio tracks if not enabled.
+
+- Fixed an issue in `BaseInputTransport` that was causing frames pushed
+  downstream not pushed in the right order.
+
 ## [0.0.15] - 2024-05-15
 
 ### Fixed

README.md

@@ -39,7 +39,7 @@ pip install "pipecat-ai[option,...]"
 
 Your project may or may not need these, so they're made available as optional requirements. Here is a list:
 
-- **AI services**: `anthropic`, `azure`, `fal`, `moondream`, `openai`, `playht`, `silero`, `whisper`
+- **AI services**: `anthropic`, `azure`, `deepgram`, `google`, `fal`, `moondream`, `openai`, `playht`, `silero`, `whisper`
 - **Transports**: `local`, `websocket`, `daily`
 
 ## Code examples

examples/foundational/05-sync-speech-and-image.py

@@ -13,12 +13,12 @@ from dataclasses import dataclass
 
 from pipecat.frames.frames import (
     AppFrame,
+    EndFrame,
     Frame,
     ImageRawFrame,
-    TextFrame,
-    EndFrame,
+    LLMFullResponseStartFrame,
     LLMMessagesFrame,
-    LLMResponseStartFrame,
+    TextFrame
 )
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
@@ -64,7 +64,7 @@ class MonthPrepender(FrameProcessor):
         elif self.prepend_to_next_text_frame and isinstance(frame, TextFrame):
             await self.push_frame(TextFrame(f"{self.most_recent_month}: {frame.text}"))
             self.prepend_to_next_text_frame = False
-        elif isinstance(frame, LLMResponseStartFrame):
+        elif isinstance(frame, LLMFullResponseStartFrame):
             self.prepend_to_next_text_frame = True
             await self.push_frame(frame)
         else:
@@ -105,7 +105,7 @@ async def main(room_url):
 
         gated_aggregator = GatedAggregator(
             gate_open_fn=lambda frame: isinstance(frame, ImageRawFrame),
-            gate_close_fn=lambda frame: isinstance(frame, LLMResponseStartFrame),
+            gate_close_fn=lambda frame: isinstance(frame, LLMFullResponseStartFrame),
             start_open=False
         )
 
@@ -114,14 +114,14 @@ async def main(room_url):
         llm_full_response_aggregator = LLMFullResponseAggregator()
 
         pipeline = Pipeline([
-            llm,
-            sentence_aggregator,
-            ParallelTask(
-                [month_prepender, tts],
-                [llm_full_response_aggregator, imagegen]
+            llm,                     # LLM
+            sentence_aggregator,     # Aggregates LLM output into full sentences
+            ParallelTask(            # Run pipelines in parallel aggregating the result
+                [month_prepender, tts],                   # Create "Month: sentence" and output audio
+                [llm_full_response_aggregator, imagegen]  # Aggregate full LLM response
             ),
-            gated_aggregator,
-            transport.output()
+            gated_aggregator,        # Queues everything until an image is available
+            transport.output()       # Transport output
         ])
 
         frames = []

examples/foundational/05a-local-sync-speech-and-image.py

@@ -98,9 +98,13 @@ async def main():
 
             image_grabber = ImageGrabber()
 
-            pipeline = Pipeline([llm, aggregator, description,
-                                 ParallelPipeline([tts, audio_grabber],
-                                                  [imagegen, image_grabber])])
+            pipeline = Pipeline([
+                llm,
+                aggregator,
+                description,
+                ParallelPipeline([tts, audio_grabber],
+                                 [imagegen, image_grabber])
+            ])
 
             task = PipelineTask(pipeline)
             await task.queue_frame(LLMMessagesFrame(messages))

examples/foundational/06-listen-and-respond.py

@@ -21,7 +21,7 @@ from pipecat.processors.logger import FrameLogger
 from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.services.openai import OpenAILLMService
 from pipecat.transports.services.daily import DailyParams, DailyTransport
-from pipecat.vad.silero import SileroVAD
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from runner import configure
 
@@ -41,14 +41,13 @@ async def main(room_url: str, token):
             token,
             "Respond bot",
             DailyParams(
-                audio_in_enabled=True,  # This is so Silero VAD can get audio data
                 audio_out_enabled=True,
-                transcription_enabled=True
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
             )
         )
 
-        vad = SileroVAD()
-
         tts = ElevenLabsTTSService(
             aiohttp_session=session,
             api_key=os.getenv("ELEVENLABS_API_KEY"),
@@ -57,22 +56,32 @@ async def main(room_url: str, token):
 
         llm = OpenAILLMService(
             api_key=os.getenv("OPENAI_API_KEY"),
-            model="gpt-4-turbo-preview")
+            model="gpt-4o")
 
-        fl_in = FrameLogger("Inner")
-        fl_out = FrameLogger("Outer")
+        fl = FrameLogger("!!! after LLM", "red")
+        fltts = FrameLogger("@@@ out of tts", "green")
+        flend = FrameLogger("### out of the end", "magenta")
 
         messages = [
             {
                 "role": "system",
-                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so it should not contain special characters. Respond to what the user said in a creative and helpful way.",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
             },
         ]
         tma_in = LLMUserResponseAggregator(messages)
         tma_out = LLMAssistantResponseAggregator(messages)
 
-        pipeline = Pipeline([fl_in, transport.input(), vad, tma_in, llm,
-                            fl_out, tts, tma_out, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            tma_in,
+            llm,
+            fl,
+            tts,
+            fltts,
+            transport.output(),
+            tma_out,
+            flend
+        ])
 
         task = PipelineTask(pipeline)
 

examples/foundational/06a-image-sync.py

@@ -15,14 +15,15 @@ from pipecat.frames.frames import ImageRawFrame, Frame, SystemFrame, TextFrame
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
 from pipecat.pipeline.task import PipelineTask
-from pipecat.processors.aggregators.llm_context import (
-    LLMAssistantContextAggregator,
-    LLMUserContextAggregator,
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator,
+    LLMUserResponseAggregator,
 )
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.services.openai import OpenAILLMService
 from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.transports.services.daily import DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from pipecat.transports.services.daily import DailyParams
 from runner import configure
@@ -66,7 +67,9 @@ async def main(room_url: str, token):
                 audio_out_enabled=True,
                 camera_out_width=1024,
                 camera_out_height=1024,
-                transcription_enabled=True
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
             )
         )
 
@@ -83,20 +86,27 @@ async def main(room_url: str, token):
         messages = [
             {
                 "role": "system",
-                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so it should not contain special characters. Respond to what the user said in a creative and helpful way.",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
             },
         ]
 
-        tma_in = LLMUserContextAggregator(messages)
-        tma_out = LLMAssistantContextAggregator(messages)
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
 
         image_sync_aggregator = ImageSyncAggregator(
             os.path.join(os.path.dirname(__file__), "assets", "speaking.png"),
             os.path.join(os.path.dirname(__file__), "assets", "waiting.png"),
         )
 
-        pipeline = Pipeline([transport.input(), image_sync_aggregator,
-                            tma_in, llm, tma_out, tts, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            image_sync_aggregator,
+            tma_in,
+            llm,
+            tts,
+            transport.output(),
+            tma_out
+        ])
 
         task = PipelineTask(pipeline)
 

examples/foundational/07-interruptible.py

@@ -1,26 +1,34 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
 import asyncio
 import aiohttp
-import logging
 import os
-from pipecat.pipeline.aggregators import (
-    LLMAssistantResponseAggregator,
-    LLMUserResponseAggregator,
-)
+import sys
 
+from pipecat.frames.frames import LLMMessagesFrame
 from pipecat.pipeline.pipeline import Pipeline
-from pipecat.services.ai_services import FrameLogger
-from pipecat.transports.daily_transport import DailyTransport
-from pipecat.services.open_ai_services import OpenAILLMService
-from pipecat.services.elevenlabs_ai_services import ElevenLabsTTSService
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator, LLMUserResponseAggregator)
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from runner import configure
 
+from loguru import logger
+
 from dotenv import load_dotenv
 load_dotenv(override=True)
 
-logging.basicConfig(format=f"%(levelno)s %(asctime)s %(message)s")
-logger = logging.getLogger("pipecat")
-logger.setLevel(logging.DEBUG)
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
 
 
 async def main(room_url: str, token):
@@ -29,12 +37,12 @@ async def main(room_url: str, token):
             room_url,
             token,
             "Respond bot",
-            duration_minutes=5,
-            start_transcription=True,
-            mic_enabled=True,
-            mic_sample_rate=16000,
-            camera_enabled=False,
-            vad_enabled=True,
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
         )
 
         tts = ElevenLabsTTSService(
@@ -47,27 +55,38 @@ async def main(room_url: str, token):
             api_key=os.getenv("OPENAI_API_KEY"),
             model="gpt-4-turbo-preview")
 
-        pipeline = Pipeline([FrameLogger(), llm, FrameLogger(), tts])
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
+            },
+        ]
 
-        @transport.event_handler("on_first_other_participant_joined")
-        async def on_first_other_participant_joined(transport, participant):
-            await transport.say("Hi, I'm listening!", tts)
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
 
-        async def run_conversation():
-            messages = [
-                {
-                    "role": "system",
-                    "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio. Respond to what the user said in a creative and helpful way.",
-                },
-            ]
+        pipeline = Pipeline([
+            transport.input(),   # Transport user input
+            tma_in,              # User responses
+            llm,                 # LLM
+            tts,                 # TTS
+            transport.output(),  # Transport bot output
+            tma_out              # Assistant spoken responses
+        ])
 
-            await transport.run_interruptible_pipeline(
-                pipeline,
-                post_processor=LLMAssistantResponseAggregator(messages),
-                pre_processor=LLMUserResponseAggregator(messages),
-            )
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
 
-        await asyncio.gather(transport.run(), run_conversation())
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            # Kick off the conversation.
+            messages.append(
+                {"role": "system", "content": "Please introduce yourself to the user."})
+            await task.queue_frames([LLMMessagesFrame(messages)])
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
 
 
 if __name__ == "__main__":

examples/foundational/07a-interruptible-anthropic.py

@@ -0,0 +1,95 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import LLMMessagesFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator, LLMUserResponseAggregator)
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.anthropic import AnthropicLLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Respond bot",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        llm = AnthropicLLMService(
+            api_key=os.getenv("ANTHROPIC_API_KEY"),
+            model="claude-3-opus-20240229")
+
+        # todo: think more about how to handle system prompts in a more general way. OpenAI,
+        # Google, and Anthropic all have slightly different approaches to providing a system
+        # prompt.
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative, helpful, and brief way. Say hello.",
+            },
+        ]
+
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
+
+        pipeline = Pipeline([
+            transport.input(),   # Transport user input
+            tma_in,              # User responses
+            llm,                 # LLM
+            tts,                 # TTS
+            transport.output(),  # Transport bot output
+            tma_out              # Assistant spoken responses
+        ])
+
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            # Kick off the conversation.
+            await task.queue_frames([LLMMessagesFrame(messages)])
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/07c-interruptible-deepgram.py

@@ -0,0 +1,94 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import LLMMessagesFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator, LLMUserResponseAggregator)
+from pipecat.services.deepgram import DeepgramTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Respond bot",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        tts = DeepgramTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("DEEPGRAM_API_KEY"),
+            voice="aura-helios-en"
+        )
+
+        llm = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4-turbo-preview")
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
+            },
+        ]
+
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
+
+        pipeline = Pipeline([
+            transport.input(),   # Transport user input
+            tma_in,              # User responses
+            llm,                 # LLM
+            tts,                 # TTS
+            transport.output(),  # Transport bot output
+            tma_out              # Assistant spoken responses
+        ])
+
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            # Kick off the conversation.
+            messages.append(
+                {"role": "system", "content": "Please introduce yourself to the user."})
+            await task.queue_frames([LLMMessagesFrame(messages)])
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/07d-interruptible-cartesia.py

@@ -0,0 +1,93 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import LLMMessagesFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator, LLMUserResponseAggregator)
+from pipecat.services.cartesia import CartesiaTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Respond bot",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        tts = CartesiaTTSService(
+            api_key=os.getenv("CARTESIA_API_KEY"),
+            voice_name="Barbershop Man"
+        )
+
+        llm = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4o")
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
+            },
+        ]
+
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
+
+        pipeline = Pipeline([
+            transport.input(),   # Transport user input
+            tma_in,              # User responses
+            llm,                 # LLM
+            tts,                 # TTS
+            transport.output(),  # Transport bot output
+            tma_out              # Assistant spoken responses
+        ])
+
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            # Kick off the conversation.
+            messages.append(
+                {"role": "system", "content": "Please introduce yourself to the user."})
+            await task.queue_frames([LLMMessagesFrame(messages)])
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/08-bots-arguing.py

@@ -3,14 +3,14 @@ import aiohttp
 import asyncio
 import logging
 import os
-from pipecat.pipeline.aggregators import SentenceAggregator
+from pipecat.processors.aggregators import SentenceAggregator
 from pipecat.pipeline.pipeline import Pipeline
 
 from pipecat.transports.daily_transport import DailyTransport
 from pipecat.services.azure_ai_services import AzureLLMService, AzureTTSService
 from pipecat.services.elevenlabs_ai_services import ElevenLabsTTSService
 from pipecat.services.fal_ai_services import FalImageGenService
-from pipecat.pipeline.frames import AudioFrame, EndFrame, ImageFrame, LLMMessagesFrame, TextFrame
+from pipecat.frames.frames import AudioFrame, EndFrame, ImageFrame, LLMMessagesFrame, TextFrame
 
 from runner import configure
 

examples/foundational/10-wake-phrase.py

@@ -0,0 +1,94 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.processors.filters.wake_check_filter import WakeCheckFilter
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantResponseAggregator, LLMUserResponseAggregator)
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+async def main(room_url: str, token):
+
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Robot",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        llm = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4o")
+
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful assistant. Respond to what the user said in a creative and helpful way. Keep your responses brief.",
+            },
+        ]
+
+        hey_robot_filter = WakeCheckFilter(["hey robot", "hey, robot"])
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
+
+        pipeline = Pipeline([
+            transport.input(),   # Transport user input
+            hey_robot_filter,    # Filter out speech not directed at the robot
+            tma_in,              # User responses
+            llm,                 # LLM
+            tts,                 # TTS
+            transport.output(),  # Transport bot output
+            tma_out              # Assistant spoken responses
+        ])
+
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            await tts.say("Hi! If you want to talk to me, just say 'Hey Robot'.")
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/10-wake-word.py

@@ -1,181 +0,0 @@
-#
-# Copyright (c) 2024, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-import asyncio
-import aiohttp
-import os
-import random
-import sys
-
-from PIL import Image
-
-from pipecat.frames.frames import (
-    Frame,
-    SystemFrame,
-    TextFrame,
-    ImageRawFrame,
-    SpriteFrame,
-    TranscriptionFrame,
-)
-from pipecat.pipeline.pipeline import Pipeline
-from pipecat.pipeline.runner import PipelineRunner
-from pipecat.pipeline.task import PipelineTask
-from pipecat.processors.aggregators.llm_context import (
-    LLMUserContextAggregator,
-    LLMAssistantContextAggregator,
-)
-from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
-from pipecat.services.openai import OpenAILLMService
-from pipecat.services.elevenlabs import ElevenLabsTTSService
-from pipecat.transports.services.daily import DailyParams, DailyTransport
-
-from runner import configure
-
-from loguru import logger
-
-from dotenv import load_dotenv
-load_dotenv(override=True)
-
-logger.remove(0)
-logger.add(sys.stderr, level="DEBUG")
-
-
-sprites = {}
-image_files = [
-    "sc-default.png",
-    "sc-talk.png",
-    "sc-listen-1.png",
-    "sc-think-1.png",
-    "sc-think-2.png",
-    "sc-think-3.png",
-    "sc-think-4.png",
-]
-
-script_dir = os.path.dirname(__file__)
-
-for file in image_files:
-    # Build the full path to the image file
-    full_path = os.path.join(script_dir, "assets", file)
-    # Get the filename without the extension to use as the dictionary key
-    filename = os.path.splitext(os.path.basename(full_path))[0]
-    # Open the image and convert it to bytes
-    with Image.open(full_path) as img:
-        sprites[file] = ImageRawFrame(image=img.tobytes(), size=img.size, format=img.format)
-
-# When the bot isn't talking, show a static image of the cat listening
-quiet_frame = sprites["sc-listen-1.png"]
-
-# When the bot is talking, build an animation from two sprites
-talking_list = [sprites["sc-default.png"], sprites["sc-talk.png"]]
-talking = [random.choice(talking_list) for x in range(30)]
-talking_frame = SpriteFrame(talking)
-
-# TODO: Support "thinking" as soon as we get a valid transcript, while LLM
-# is processing
-thinking_list = [
-    sprites["sc-think-1.png"],
-    sprites["sc-think-2.png"],
-    sprites["sc-think-3.png"],
-    sprites["sc-think-4.png"],
-]
-thinking_frame = SpriteFrame(thinking_list)
-
-
-class NameCheckFilter(FrameProcessor):
-    def __init__(self, names: list[str]):
-        super().__init__()
-        self._names = names
-        self._sentence = ""
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        if isinstance(frame, SystemFrame):
-            await self.push_frame(frame, direction)
-            return
-
-        content: str = ""
-
-        # TODO: split up transcription by participant
-        if isinstance(frame, TranscriptionFrame):
-            content = frame.text
-            self._sentence += content
-            if self._sentence.endswith((".", "?", "!")):
-                if any(name in self._sentence for name in self._names):
-                    await self.push_frame(TextFrame(self._sentence))
-                    self._sentence = ""
-                else:
-                    self._sentence = ""
-        else:
-            await self.push_frame(frame, direction)
-
-
-class ImageSyncAggregator(FrameProcessor):
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        await self.push_frame(talking_frame)
-        await self.push_frame(frame)
-        await self.push_frame(quiet_frame)
-
-
-async def main(room_url: str, token):
-    async with aiohttp.ClientSession() as session:
-        transport = DailyTransport(
-            room_url,
-            token,
-            "Santa Cat",
-            DailyParams(
-                audio_out_enabled=True,
-                camera_out_enabled=True,
-                camera_out_width=720,
-                camera_out_height=1280,
-                camera_out_framerate=10,
-                transcription_enabled=True
-            )
-        )
-
-        llm = OpenAILLMService(
-            api_key=os.getenv("OPENAI_API_KEY"),
-            model="gpt-4-turbo-preview")
-
-        tts = ElevenLabsTTSService(
-            aiohttp_session=session,
-            api_key=os.getenv("ELEVENLABS_API_KEY"),
-            voice_id="jBpfuIE2acCO8z3wKNLl",
-        )
-        isa = ImageSyncAggregator()
-
-        messages = [
-            {
-                "role": "system",
-                "content": "You are Santa Cat, a cat that lives in Santa's workshop at the North Pole. You should be clever, and a bit sarcastic. You should also tell jokes every once in a while.  Your responses should only be a few sentences long.",
-            },
-        ]
-
-        tma_in = LLMUserContextAggregator(messages)
-        tma_out = LLMAssistantContextAggregator(messages)
-        ncf = NameCheckFilter(["Santa Cat", "Santa"])
-
-        pipeline = Pipeline([transport.input(), isa, ncf, tma_in,
-                            llm, tma_out, tts, transport.output()])
-
-        @transport.event_handler("on_first_participant_joined")
-        async def on_first_participant_joined(transport, participant):
-            # Send some greeting at the beginning.
-            await tts.say("Hi! If you want to talk to me, just say 'hey Santa Cat'.")
-            transport.capture_participant_transcription(participant["id"])
-
-        async def starting_image():
-            await transport.send_image(quiet_frame)
-
-        runner = PipelineRunner()
-
-        task = PipelineTask(pipeline)
-
-        await asyncio.gather(runner.run(task), starting_image())
-
-
-if __name__ == "__main__":
-    (url, token) = configure()
-    asyncio.run(main(url, token))

examples/foundational/11-sound-effects.py

@@ -13,21 +13,22 @@ import wave
 from pipecat.frames.frames import (
     Frame,
     AudioRawFrame,
-    LLMResponseEndFrame,
+    LLMFullResponseEndFrame,
     LLMMessagesFrame,
 )
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
 from pipecat.pipeline.task import PipelineTask
-from pipecat.processors.aggregators.llm_context import (
-    LLMUserContextAggregator,
-    LLMAssistantContextAggregator,
+from pipecat.processors.aggregators.llm_response import (
+    LLMUserResponseAggregator,
+    LLMAssistantResponseAggregator,
 )
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.processors.logger import FrameLogger
 from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.services.openai import OpenAILLMService
 from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from runner import configure
 
@@ -59,7 +60,7 @@ for file in sound_files:
 class OutboundSoundEffectWrapper(FrameProcessor):
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
-        if isinstance(frame, LLMResponseEndFrame):
+        if isinstance(frame, LLMFullResponseEndFrame):
             await self.push_frame(sounds["ding1.wav"])
             # In case anything else downstream needs it
             await self.push_frame(frame, direction)
@@ -84,7 +85,12 @@ async def main(room_url: str, token):
             room_url,
             token,
             "Respond bot",
-            DailyParams(audio_out_enabled=True, transcription_enabled=True)
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
         )
 
         llm = OpenAILLMService(
@@ -104,15 +110,25 @@ async def main(room_url: str, token):
             },
         ]
 
-        tma_in = LLMUserContextAggregator(messages)
-        tma_out = LLMAssistantContextAggregator(messages)
+        tma_in = LLMUserResponseAggregator(messages)
+        tma_out = LLMAssistantResponseAggregator(messages)
         out_sound = OutboundSoundEffectWrapper()
         in_sound = InboundSoundEffectWrapper()
         fl = FrameLogger("LLM Out")
         fl2 = FrameLogger("Transcription In")
 
-        pipeline = Pipeline([transport.input(), tma_in, in_sound, fl2, llm,
-                            tma_out, fl, tts, out_sound, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            tma_in,
+            in_sound,
+            fl2,
+            llm,
+            fl,
+            tts,
+            out_sound,
+            transport.output(),
+            tma_out
+        ])
 
         @transport.event_handler("on_first_participant_joined")
         async def on_first_participant_joined(transport, participant):

examples/foundational/12-describe-video.py

@@ -19,7 +19,7 @@ from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.services.moondream import MoondreamService
 from pipecat.transports.services.daily import DailyParams, DailyTransport
-from pipecat.vad.silero import SileroVAD
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from runner import configure
 
@@ -54,14 +54,13 @@ async def main(room_url: str, token):
             token,
             "Describe participant video",
             DailyParams(
-                audio_in_enabled=True,  # This is so Silero VAD can get audio data
                 audio_out_enabled=True,
-                transcription_enabled=True
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
             )
         )
 
-        vad = SileroVAD()
-
         tts = ElevenLabsTTSService(
             aiohttp_session=session,
             api_key=os.getenv("ELEVENLABS_API_KEY"),
@@ -90,8 +89,15 @@ async def main(room_url: str, token):
             transport.capture_participant_transcription(participant["id"])
             image_requester.set_participant_id(participant["id"])
 
-        pipeline = Pipeline([transport.input(), vad, user_response, image_requester,
-                             vision_aggregator, moondream, tts, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            user_response,
+            image_requester,
+            vision_aggregator,
+            moondream,
+            tts,
+            transport.output()
+        ])
 
         task = PipelineTask(pipeline)
 

examples/foundational/12a-describe-video-gemini-flash.py

@@ -0,0 +1,106 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import Frame, TextFrame, UserImageRequestFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask
+from pipecat.processors.aggregators.user_response import UserResponseAggregator
+from pipecat.processors.aggregators.vision_image_frame import VisionImageFrameAggregator
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.google import GoogleLLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+class UserImageRequester(FrameProcessor):
+
+    def __init__(self, participant_id: str | None = None):
+        super().__init__()
+        self._participant_id = participant_id
+
+    def set_participant_id(self, participant_id: str):
+        self._participant_id = participant_id
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        if self._participant_id and isinstance(frame, TextFrame):
+            await self.push_frame(UserImageRequestFrame(self._participant_id), FrameDirection.UPSTREAM)
+        await self.push_frame(frame, direction)
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Describe participant video",
+            DailyParams(
+                audio_in_enabled=True,  # This is so Silero VAD can get audio data
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        user_response = UserResponseAggregator()
+
+        image_requester = UserImageRequester()
+
+        vision_aggregator = VisionImageFrameAggregator()
+
+        google = GoogleLLMService(
+            model="gemini-1.5-flash-latest",
+            api_key=os.getenv("GOOGLE_API_KEY"))
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            await tts.say("Hi there! Feel free to ask me what I see.")
+            transport.capture_participant_video(participant["id"], framerate=0)
+            transport.capture_participant_transcription(participant["id"])
+            image_requester.set_participant_id(participant["id"])
+
+        pipeline = Pipeline([
+            transport.input(),
+            user_response,
+            image_requester,
+            vision_aggregator,
+            google,
+            tts,
+            transport.output()
+        ])
+
+        task = PipelineTask(pipeline)
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/12b-describe-video-gpt-4o.py

@@ -0,0 +1,106 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import Frame, TextFrame, UserImageRequestFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask
+from pipecat.processors.aggregators.user_response import UserResponseAggregator
+from pipecat.processors.aggregators.vision_image_frame import VisionImageFrameAggregator
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+class UserImageRequester(FrameProcessor):
+
+    def __init__(self, participant_id: str | None = None):
+        super().__init__()
+        self._participant_id = participant_id
+
+    def set_participant_id(self, participant_id: str):
+        self._participant_id = participant_id
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        if self._participant_id and isinstance(frame, TextFrame):
+            await self.push_frame(UserImageRequestFrame(self._participant_id), FrameDirection.UPSTREAM)
+        await self.push_frame(frame, direction)
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Describe participant video",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        user_response = UserResponseAggregator()
+
+        image_requester = UserImageRequester()
+
+        vision_aggregator = VisionImageFrameAggregator()
+
+        openai = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4o"
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            await tts.say("Hi there! Feel free to ask me what I see.")
+            transport.capture_participant_video(participant["id"], framerate=0)
+            transport.capture_participant_transcription(participant["id"])
+            image_requester.set_participant_id(participant["id"])
+
+        pipeline = Pipeline([
+            transport.input(),
+            user_response,
+            image_requester,
+            vision_aggregator,
+            openai,
+            tts,
+            transport.output()
+        ])
+
+        task = PipelineTask(pipeline)
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/12c-describe-video-anthropic.py

@@ -0,0 +1,106 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import sys
+
+from pipecat.frames.frames import Frame, TextFrame, UserImageRequestFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask
+from pipecat.processors.aggregators.user_response import UserResponseAggregator
+from pipecat.processors.aggregators.vision_image_frame import VisionImageFrameAggregator
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.anthropic import AnthropicLLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+class UserImageRequester(FrameProcessor):
+
+    def __init__(self, participant_id: str | None = None):
+        super().__init__()
+        self._participant_id = participant_id
+
+    def set_participant_id(self, participant_id: str):
+        self._participant_id = participant_id
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        if self._participant_id and isinstance(frame, TextFrame):
+            await self.push_frame(UserImageRequestFrame(self._participant_id), FrameDirection.UPSTREAM)
+        await self.push_frame(frame, direction)
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Describe participant video",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        user_response = UserResponseAggregator()
+
+        image_requester = UserImageRequester()
+
+        vision_aggregator = VisionImageFrameAggregator()
+
+        anthropic = AnthropicLLMService(
+            api_key=os.getenv("ANTHROPIC_API_KEY"),
+            model="claude-3-sonnet-20240229"
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            await tts.say("Hi there! Feel free to ask me what I see.")
+            transport.capture_participant_video(participant["id"], framerate=0)
+            transport.capture_participant_transcription(participant["id"])
+            image_requester.set_participant_id(participant["id"])
+
+        pipeline = Pipeline([
+            transport.input(),
+            user_response,
+            image_requester,
+            vision_aggregator,
+            anthropic,
+            tts,
+            transport.output()
+        ])
+
+        task = PipelineTask(pipeline)
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/14-function-calling.py

@@ -0,0 +1,145 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import asyncio
+import aiohttp
+import os
+import json
+import sys
+
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask
+from pipecat.processors.aggregators.llm_response import (
+    LLMAssistantContextAggregator,
+    LLMUserContextAggregator,
+)
+from pipecat.services.openai import OpenAILLMContext
+from pipecat.processors.logger import FrameLogger
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.transports.services.daily import DailyParams, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+from openai.types.chat import (
+    ChatCompletionToolParam,
+)
+from pipecat.frames.frames import (
+    TextFrame
+)
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+
+async def start_fetch_weather(llm):
+    await llm.push_frame(TextFrame("Let me think."))
+
+
+async def fetch_weather_from_api(llm, args):
+    return ({"conditions": "nice", "temperature": "75"})
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Respond bot",
+            DailyParams(
+                audio_out_enabled=True,
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
+            )
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            voice_id=os.getenv("ELEVENLABS_VOICE_ID"),
+        )
+
+        llm = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4-turbo-preview")
+        llm.register_function(
+            "get_current_weather",
+            fetch_weather_from_api,
+            start_callback=start_fetch_weather)
+
+        fl_in = FrameLogger("Inner")
+        fl_out = FrameLogger("Outer")
+
+        tools = [
+            ChatCompletionToolParam(
+                type="function",
+                function={
+                    "name": "get_current_weather",
+                    "description": "Get the current weather",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "location": {
+                                "type": "string",
+                                "description": "The city and state, e.g. San Francisco, CA",
+                            },
+                            "format": {
+                                "type": "string",
+                                "enum": [
+                                    "celsius",
+                                    "fahrenheit"],
+                                "description": "The temperature unit to use. Infer this from the users location.",
+                            },
+                        },
+                        "required": [
+                            "location",
+                            "format"],
+                    },
+                })]
+        messages = [
+            {
+                "role": "system",
+                "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
+            },
+        ]
+
+        context = OpenAILLMContext(messages, tools)
+        tma_in = LLMUserContextAggregator(context)
+        tma_out = LLMAssistantContextAggregator(context)
+        pipeline = Pipeline([
+            fl_in,
+            transport.input(),
+            tma_in,
+            llm,
+            fl_out,
+            tts,
+            transport.output(),
+            tma_out
+        ])
+
+        task = PipelineTask(pipeline)
+
+        @ transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            # Kick off the conversation.
+            await tts.say("Hi! Ask me about the weather in San Francisco.")
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/foundational/websocket-server/sample.py

@@ -2,8 +2,8 @@ import asyncio
 import aiohttp
 import logging
 import os
-from pipecat.pipeline.frame_processor import FrameProcessor
-from pipecat.pipeline.frames import TextFrame, TranscriptionFrame
+from pipeline.processors.frame_processor import FrameProcessor
+from pipecat.frames.frames import TextFrame, TranscriptionFrame
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.services.elevenlabs_ai_services import ElevenLabsTTSService
 from pipecat.transports.websocket_transport import WebsocketTransport

examples/moondream-chatbot/bot.py

@@ -29,7 +29,7 @@ from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.services.moondream import MoondreamService
 from pipecat.services.openai import OpenAILLMService
 from pipecat.transports.services.daily import DailyParams, DailyTransport
-from pipecat.vad.silero import SileroVAD
+from pipecat.vad.silero import SileroVADAnalyzer
 
 from runner import configure
 
@@ -66,7 +66,7 @@ talking_frame = SpriteFrame(images=sprites)
 class TalkingAnimation(FrameProcessor):
     """
     This class starts a talking animation when it receives an first AudioFrame,
-    and then returns to a "quiet" sprite when it sees a LLMResponseEndFrame.
+    and then returns to a "quiet" sprite when it sees a TTSStoppedFrame.
     """
 
     def __init__(self):
@@ -127,17 +127,16 @@ async def main(room_url: str, token):
             token,
             "Chatbot",
             DailyParams(
-                audio_in_enabled=True,
                 audio_out_enabled=True,
                 camera_out_enabled=True,
                 camera_out_width=1024,
                 camera_out_height=576,
-                transcription_enabled=True
+                transcription_enabled=True,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer()
             )
         )
 
-        vad = SileroVAD()
-
         tts = ElevenLabsTTSService(
             aiohttp_session=session,
             api_key=os.getenv("ELEVENLABS_API_KEY"),
@@ -163,17 +162,23 @@ async def main(room_url: str, token):
         messages = [
             {
                 "role": "system",
-                "content": f"You are Chatbot, a friendly, helpful robot. Let the user know that you are capable of chatting or describing what you see. Your goal is to demonstrate your capabilities in a succinct way. Reply with only '{user_request_answer}' if the user asks you to describe what you see. Your output will be converted to audio so never include special characters in your answers. Respond to what the user said in a creative and helpful way, but keep your responses brief. Start by introducing yourself.",
+                "content": f"You are Chatbot, a friendly, helpful robot. Let the user know that you are capable of chatting or describing what you see. Your goal is to demonstrate your capabilities in a succinct way. Reply with only '{user_request_answer}' if the user asks you to describe what you see. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way, but keep your responses brief. Start by introducing yourself.",
             },
         ]
 
         ura = LLMUserResponseAggregator(messages)
 
-        pipeline = Pipeline([transport.input(), vad, ura, llm,
-                             ParallelPipeline(
-                                 [sa, ir, va, moondream],
-                                 [tf, imgf]),
-                             tts, ta, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            ura,
+            llm,
+            ParallelPipeline(
+                [sa, ir, va, moondream],
+                [tf, imgf]),
+            tts,
+            ta,
+            transport.output()
+        ])
 
         task = PipelineTask(pipeline)
         await task.queue_frame(quiet_frame)

examples/patient-intake/Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-bullseye
+
+RUN mkdir /app
+RUN mkdir /app/assets
+RUN mkdir /app/utils
+COPY *.py /app/
+COPY requirements.txt /app/
+copy assets/* /app/assets/
+copy utils/* /app/utils/
+
+WORKDIR /app
+RUN pip3 install -r requirements.txt
+
+EXPOSE 7860
+
+CMD ["python3", "server.py"]

examples/patient-intake/README.md

@@ -0,0 +1,37 @@
+# Simple Chatbot
+
+<img src="image.png" width="420px">
+
+This app connects you to a chatbot powered by GPT-4, complete with animations generated by Stable Video Diffusion.
+
+See a video of it in action: https://x.com/kwindla/status/1778628911817183509
+
+And a quick video walkthrough of the code: https://www.loom.com/share/13df1967161f4d24ade054e7f8753416
+
+ℹ️ The first time, things might take extra time to get started since VAD (Voice Activity Detection) model needs to be downloaded.
+
+## Get started
+
+```python
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+cp env.example .env # and add your credentials
+
+```
+
+## Run the server
+
+```bash
+python server.py
+```
+
+Then, visit `http://localhost:7860/start` in your browser to start a chatbot session.
+
+## Build and test the Docker image
+
+```
+docker build -t chatbot .
+docker run --env-file .env -p 7860:7860 chatbot
+```

examples/patient-intake/bot.py

@@ -0,0 +1,359 @@
+import asyncio
+import aiohttp
+import copy
+import json
+import os
+import re
+import sys
+import wave
+from typing import List
+
+from openai._types import NotGiven, NOT_GIVEN
+
+from openai.types.chat import (
+    ChatCompletionToolParam,
+)
+
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineTask
+from pipecat.processors.aggregators.llm_response import LLMUserContextAggregator, LLMAssistantContextAggregator
+from pipecat.processors.logger import FrameLogger
+from pipecat.frames.frames import (
+    Frame,
+    LLMMessagesFrame,
+    AudioRawFrame,
+)
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.services.elevenlabs import ElevenLabsTTSService
+from pipecat.services.openai import OpenAILLMService
+from pipecat.services.ai_services import AIService
+from pipecat.transports.services.daily import DailyParams, DailyTranscriptionSettings, DailyTransport
+from pipecat.vad.silero import SileroVADAnalyzer
+from pipecat.services.openai import OpenAILLMContext, OpenAILLMContextFrame
+
+from runner import configure
+
+from loguru import logger
+
+from dotenv import load_dotenv
+load_dotenv(override=True)
+
+logger.remove(0)
+logger.add(sys.stderr, level="DEBUG")
+
+sounds = {}
+sound_files = [
+    "clack-short.wav",
+    "clack.wav",
+    "clack-short-quiet.wav",
+    "ding.wav",
+    "ding2.wav",
+]
+
+script_dir = os.path.dirname(__file__)
+
+for file in sound_files:
+    # Build the full path to the sound file
+    full_path = os.path.join(script_dir, "assets", file)
+    # Get the filename without the extension to use as the dictionary key
+    filename = os.path.splitext(os.path.basename(full_path))[0]
+    # Open the sound and convert it to bytes
+    with wave.open(full_path) as audio_file:
+        sounds[file] = AudioRawFrame(audio_file.readframes(-1),
+                                     audio_file.getframerate(), audio_file.getnchannels())
+
+
+class IntakeProcessor:
+    def __init__(
+        self,
+        context: OpenAILLMContext,
+        llm: AIService,
+        tools: List[ChatCompletionToolParam] | NotGiven = NOT_GIVEN,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self._context: OpenAILLMContext = context
+        self._llm = llm
+        print(f"Initializing context from IntakeProcessor")
+        self._context.add_message({"role": "system", "content": "You are Jessica, an agent for a company called Tri-County Health Services. Your job is to collect important information from the user before their doctor visit. You're talking to Chad Bailey. You should address the user by their first name and be polite and professional. You're not a medical professional, so you shouldn't provide any advice. Keep your responses short. Your job is to collect information to give to a doctor. Don't make assumptions about what values to plug into functions. Ask for clarification if a user response is ambiguous. Start by introducing yourself. Then, ask the user to confirm their identity by telling you their birthday, including the year. When they answer with their birthday, call the verify_birthday function."})
+        self._context.set_tools([
+            {
+                "type": "function",
+                "function": {
+                    "name": "verify_birthday",
+                    "description": "Use this function to verify the user has provided their correct birthday.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "birthday": {
+                                "type": "string",
+                                "description": "The user's birthdate, including the year. The user can provide it in any format, but convert it to YYYY-MM-DD format to call this function.",
+                            }},
+                    },
+                },
+            }])
+        # Create an allowlist of functions that the LLM can call
+        self._functions = [
+            "verify_birthday",
+            "list_prescriptions",
+            "list_allergies",
+            "list_conditions",
+            "list_visit_reasons",
+        ]
+
+    async def verify_birthday(self, llm, args):
+        if args["birthday"] == "1983-01-01":
+            self._context.set_tools(
+                [
+                    {
+                        "type": "function",
+                        "function": {
+                            "name": "list_prescriptions",
+                            "description": "Once the user has provided a list of their prescription medications, call this function.",
+                            "parameters": {
+                                "type": "object",
+                                "properties": {
+                                    "prescriptions": {
+                                        "type": "array",
+                                        "items": {
+                                            "type": "object",
+                                            "properties": {
+                                                "medication": {
+                                                    "type": "string",
+                                                    "description": "The medication's name",
+                                                },
+                                                "dosage": {
+                                                    "type": "string",
+                                                    "description": "The prescription's dosage",
+                                                },
+                                            },
+                                        },
+                                    }},
+                            },
+                        },
+                    }])
+            # It's a bit weird to push this to the LLM, but it gets it into the pipeline
+            await llm.push_frame(sounds["ding2.wav"], FrameDirection.DOWNSTREAM)
+            # We don't need the function call in the context, so just return a new
+            # system message and let the framework re-prompt
+            return [{"role": "system", "content": "Next, thank the user for confirming their identity, then ask the user to list their current prescriptions. Each prescription needs to have a medication name and a dosage. Do not call the list_prescriptions function with any unknown dosages."}]
+        else:
+            # The user provided an incorrect birthday; ask them to try again
+            return [{"role": "system", "content": "The user provided an incorrect birthday. Ask them for their birthday again. When they answer, call the verify_birthday function."}]
+
+    async def start_prescriptions(self, llm):
+        print(f"!!! doing start prescriptions")
+        # Move on to allergies
+        self._context.set_tools(
+            [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "list_allergies",
+                        "description": "Once the user has provided a list of their allergies, call this function.",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "allergies": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "name": {
+                                                "type": "string",
+                                                "description": "What the user is allergic to",
+                                            }},
+                                    },
+                                }},
+                        },
+                    },
+                }])
+        self._context.add_message(
+            {
+                "role": "system",
+                "content": "Next, ask the user if they have any allergies. Once they have listed their allergies or confirmed they don't have any, call the list_allergies function."})
+        print(f"!!! about to await llm process frame in start prescrpitions")
+        await llm.process_frame(OpenAILLMContextFrame(self._context), FrameDirection.DOWNSTREAM)
+        print(f"!!! past await process frame in start prescriptions")
+
+    async def start_allergies(self, llm):
+        print("!!! doing start allergies")
+        # Move on to conditions
+        self._context.set_tools(
+            [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "list_conditions",
+                        "description": "Once the user has provided a list of their medical conditions, call this function.",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "conditions": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "name": {
+                                                "type": "string",
+                                                "description": "The user's medical condition",
+                                            }},
+                                    },
+                                }},
+                        },
+                    },
+                },
+            ])
+        self._context.add_message(
+            {
+                "role": "system",
+                "content": "Now ask the user if they have any medical conditions the doctor should know about. Once they've answered the question, call the list_conditions function."})
+        await llm.process_frame(OpenAILLMContextFrame(self._context), FrameDirection.DOWNSTREAM)
+
+    async def start_conditions(self, llm):
+        print("!!! doing start conditions")
+        # Move on to visit reasons
+        self._context.set_tools(
+            [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "list_visit_reasons",
+                        "description": "Once the user has provided a list of the reasons they are visiting a doctor today, call this function.",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "visit_reasons": {
+                                    "type": "array",
+                                    "items": {
+                                        "type": "object",
+                                        "properties": {
+                                            "name": {
+                                                "type": "string",
+                                                "description": "The user's reason for visiting the doctor",
+                                            }},
+                                    },
+                                }},
+                        },
+                    },
+                }])
+        self._context.add_message(
+            {"role": "system", "content": "Finally, ask the user the reason for their doctor visit today. Once they answer, call the list_visit_reasons function."})
+        await llm.process_frame(OpenAILLMContextFrame(self._context), FrameDirection.DOWNSTREAM)
+        pass
+
+    async def start_visit_reasons(self, llm):
+        print("!!! doing start visit reasons")
+        # move to finish call
+        self._context.set_tools([])
+        self._context.add_message({"role": "system",
+                                   "content": "Now, thank the user and end the conversation."})
+        await llm.process_frame(OpenAILLMContextFrame(self._context), FrameDirection.DOWNSTREAM)
+        pass
+
+    async def save_data(self, llm, args):
+        logger.info(f"!!! Saving data: {args}")
+        # Since this is supposed to be "async", returning None from the callback
+        # will prevent adding anything to context or re-prompting
+        return None
+
+
+async def main(room_url: str, token):
+    async with aiohttp.ClientSession() as session:
+        transport = DailyTransport(
+            room_url,
+            token,
+            "Chatbot",
+            DailyParams(
+                audio_out_enabled=True,
+                camera_out_enabled=True,
+                camera_out_width=1024,
+                camera_out_height=576,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer(),
+                transcription_enabled=True,
+                #
+                # Spanish
+                #
+                # transcription_settings=DailyTranscriptionSettings(
+                #     language="es",
+                #     tier="nova",
+                #     model="2-general"
+                # )
+            )
+        )
+
+        tts = ElevenLabsTTSService(
+            aiohttp_session=session,
+            api_key=os.getenv("ELEVENLABS_API_KEY"),
+            #
+            # English
+            #
+            voice_id="pNInz6obpgDQGcFmaJgB",
+
+            #
+            # Spanish
+            #
+            # model="eleven_multilingual_v2",
+            # voice_id="gD1IexrzCvsXPHUuT0s3",
+        )
+
+        llm = OpenAILLMService(
+            api_key=os.getenv("OPENAI_API_KEY"),
+            model="gpt-4o")
+
+        messages = []
+        context = OpenAILLMContext(
+            messages=messages,
+        )
+        user_context = LLMUserContextAggregator(context)
+        assistant_context = LLMAssistantContextAggregator(context)
+        # checklist = ChecklistProcessor(context, llm)
+        intake = IntakeProcessor(context, llm)
+        llm.register_function("verify_birthday", intake.verify_birthday)
+        llm.register_function(
+            "list_prescriptions",
+            intake.save_data,
+            start_callback=intake.start_prescriptions)
+        llm.register_function(
+            "list_allergies",
+            intake.save_data,
+            start_callback=intake.start_allergies)
+        llm.register_function(
+            "list_conditions",
+            intake.save_data,
+            start_callback=intake.start_conditions)
+        llm.register_function(
+            "list_visit_reasons",
+            intake.save_data,
+            start_callback=intake.start_visit_reasons)
+        fl = FrameLogger("LLM Output")
+
+        pipeline = Pipeline([
+            transport.input(),
+            user_context,
+            llm,
+            fl,
+            tts,
+            transport.output(),
+            assistant_context,
+        ])
+
+        task = PipelineTask(pipeline, allow_interruptions=False)
+
+        @transport.event_handler("on_first_participant_joined")
+        async def on_first_participant_joined(transport, participant):
+            transport.capture_participant_transcription(participant["id"])
+            print(f"Context is: {context}")
+            await task.queue_frames([OpenAILLMContextFrame(context)])
+
+        runner = PipelineRunner()
+
+        await runner.run(task)
+
+
+if __name__ == "__main__":
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/patient-intake/env.example

@@ -0,0 +1,4 @@
+DAILY_SAMPLE_ROOM_URL=https://yourdomain.daily.co/yourroom # (for joining the bot to the same room repeatedly for local dev)
+DAILY_API_KEY=7df...
+OPENAI_API_KEY=sk-PL...
+ELEVENLABS_API_KEY=aeb...

examples/patient-intake/requirements.txt

@@ -0,0 +1,5 @@
+python-dotenv
+requests
+fastapi[all]
+uvicorn
+pipecat-ai[daily,openai,silero]

examples/patient-intake/runner.py

@@ -0,0 +1,58 @@
+import argparse
+import os
+import time
+import urllib
+import requests
+
+
+def configure():
+    parser = argparse.ArgumentParser(description="Daily AI SDK Bot Sample")
+    parser.add_argument(
+        "-u",
+        "--url",
+        type=str,
+        required=False,
+        help="URL of the Daily room to join")
+    parser.add_argument(
+        "-k",
+        "--apikey",
+        type=str,
+        required=False,
+        help="Daily API Key (needed to create an owner token for the room)",
+    )
+
+    args, unknown = parser.parse_known_args()
+
+    url = args.url or os.getenv("DAILY_SAMPLE_ROOM_URL")
+    key = args.apikey or os.getenv("DAILY_API_KEY")
+
+    if not url:
+        raise Exception(
+            "No Daily room specified. use the -u/--url option from the command line, or set DAILY_SAMPLE_ROOM_URL in your environment to specify a Daily room URL.")
+
+    if not key:
+        raise Exception("No Daily API key specified. use the -k/--apikey option from the command line, or set DAILY_API_KEY in your environment to specify a Daily API key, available from https://dashboard.daily.co/developers.")
+
+    # Create a meeting token for the given room with an expiration 1 hour in
+    # the future.
+    room_name: str = urllib.parse.urlparse(url).path[1:]
+    expiration: float = time.time() + 60 * 60
+
+    res: requests.Response = requests.post(
+        f"https://api.daily.co/v1/meeting-tokens",
+        headers={
+            "Authorization": f"Bearer {key}"},
+        json={
+            "properties": {
+                "room_name": room_name,
+                "is_owner": True,
+                "exp": expiration}},
+    )
+
+    if res.status_code != 200:
+        raise Exception(
+            f"Failed to create meeting token: {res.status_code} {res.text}")
+
+    token: str = res.json()["token"]
+
+    return (url, token)

examples/patient-intake/server.py

@@ -0,0 +1,124 @@
+import os
+import argparse
+import subprocess
+import atexit
+
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, RedirectResponse
+
+from utils.daily_helpers import create_room as _create_room, get_token
+
+MAX_BOTS_PER_ROOM = 1
+
+# Bot sub-process dict for status reporting and concurrency control
+bot_procs = {}
+
+
+def cleanup():
+    # Clean up function, just to be extra safe
+    for proc in bot_procs.values():
+        proc.terminate()
+        proc.wait()
+
+
+atexit.register(cleanup)
+
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/start")
+async def start_agent(request: Request):
+    print(f"!!! Creating room")
+    room_url, room_name = _create_room()
+    print(f"!!! Room URL: {room_url}")
+    # Ensure the room property is present
+    if not room_url:
+        raise HTTPException(
+            status_code=500,
+            detail="Missing 'room' property in request data. Cannot start agent without a target room!")
+
+    # Check if there is already an existing process running in this room
+    num_bots_in_room = sum(
+        1 for proc in bot_procs.values() if proc[1] == room_url and proc[0].poll() is None)
+    if num_bots_in_room >= MAX_BOTS_PER_ROOM:
+        raise HTTPException(
+            status_code=500, detail=f"Max bot limited reach for room: {room_url}")
+
+    # Get the token for the room
+    token = get_token(room_url)
+
+    if not token:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to get token for room: {room_url}")
+
+    # Spawn a new agent, and join the user session
+    # Note: this is mostly for demonstration purposes (refer to 'deployment' in README)
+    try:
+        proc = subprocess.Popen(
+            [
+                f"python3 -m bot -u {room_url} -t {token}"
+            ],
+            shell=True,
+            bufsize=1,
+            cwd=os.path.dirname(os.path.abspath(__file__))
+        )
+        bot_procs[proc.pid] = (proc, room_url)
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to start subprocess: {e}")
+
+    return RedirectResponse(room_url)
+
+
+@app.get("/status/{pid}")
+def get_status(pid: int):
+    # Look up the subprocess
+    proc = bot_procs.get(pid)
+
+    # If the subprocess doesn't exist, return an error
+    if not proc:
+        raise HTTPException(
+            status_code=404, detail=f"Bot with process id: {pid} not found")
+
+    # Check the status of the subprocess
+    if proc[0].poll() is None:
+        status = "running"
+    else:
+        status = "finished"
+
+    return JSONResponse({"bot_id": pid, "status": status})
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    default_host = os.getenv("HOST", "0.0.0.0")
+    default_port = int(os.getenv("FAST_API_PORT", "7860"))
+
+    parser = argparse.ArgumentParser(
+        description="Daily Storyteller FastAPI server")
+    parser.add_argument("--host", type=str,
+                        default=default_host, help="Host address")
+    parser.add_argument("--port", type=int,
+                        default=default_port, help="Port number")
+    parser.add_argument("--reload", action="store_true",
+                        help="Reload code on change")
+
+    config = parser.parse_args()
+    print(f"to join a test room, visit http://localhost:{config.port}/start")
+    uvicorn.run(
+        "server:app",
+        host=config.host,
+        port=config.port,
+        reload=config.reload,
+    )

examples/patient-intake/utils/daily_helpers.py

@@ -1,5 +1,4 @@
 
-from re import X
 import urllib.parse
 import os
 import time
@@ -10,11 +9,11 @@ from dotenv import load_dotenv
 load_dotenv()
 
 
-daily_api_path = os.getenv("DAILY_API_URL", "api.daily.co/v1")
+daily_api_path = os.getenv("DAILY_API_URL") or "api.daily.co/v1"
 daily_api_key = os.getenv("DAILY_API_KEY")
 
 
-def create_room(expiry_time=5 * 60) -> tuple[str, str]:
+def create_room() -> tuple[str, str]:
     """
     Helper function to create a Daily room.
     # See: https://docs.daily.co/reference/rest-api/rooms
@@ -26,7 +25,7 @@ def create_room(expiry_time=5 * 60) -> tuple[str, str]:
         Exception: If the request to create the room fails or if the response does not contain the room URL or room name.
     """
     room_props = {
-        "exp": time.time() * expiry_time,
+        "exp": time.time() + 60 * 60,  # 1 hour
         "enable_chat": True,
         "enable_emoji_reactions": True,
         "eject_at_room_exp": True,
@@ -51,31 +50,6 @@ def create_room(expiry_time=5 * 60) -> tuple[str, str]:
     return room_url, room_name
 
 
-def check_room_url(room_url: str) -> bool:
-    """
-    Checks if a room exists in Daily.
-    # See: https://docs.daily.co/reference/rest-api/rooms/get-room-config
-
-    Args:
-        room_name (str): The url of the room to check for
-
-    Returns:
-        bool: True if 200 OK, Exception otherwise.
-    """
-
-    room_name = get_name_from_url(room_url)
-
-    res: requests.Response = requests.get(
-        f"https://{daily_api_path}/rooms/{room_name}",
-        headers={"Authorization": f"Bearer {daily_api_key}"}
-    )
-
-    if res.status_code != 200:
-        raise Exception(f"Room not found: {room_name}")
-
-    return True
-
-
 def get_name_from_url(room_url: str) -> str:
     """
     Extracts the name from a given room URL.

examples/simple-chatbot/bot.py

@@ -2,14 +2,13 @@ import asyncio
 import aiohttp
 import os
 import sys
-import argparse
 
 from PIL import Image
 
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
-from pipecat.pipeline.task import PipelineTask
-from pipecat.processors.aggregators.llm_response import LLMUserResponseAggregator
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_response import LLMAssistantResponseAggregator, LLMUserResponseAggregator
 from pipecat.frames.frames import (
     AudioRawFrame,
     ImageRawFrame,
@@ -22,7 +21,9 @@ from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.services.elevenlabs import ElevenLabsTTSService
 from pipecat.services.openai import OpenAILLMService
 from pipecat.transports.services.daily import DailyParams, DailyTranscriptionSettings, DailyTransport
-from pipecat.vad.silero import SileroVAD
+from pipecat.vad.silero import SileroVADAnalyzer
+
+from runner import configure
 
 from loguru import logger
 
@@ -42,8 +43,7 @@ for i in range(1, 26):
     # Get the filename without the extension to use as the dictionary key
     # Open the image and convert it to bytes
     with Image.open(full_path) as img:
-        sprites.append(ImageRawFrame(image=img.tobytes(),
-                       size=img.size, format=img.format))
+        sprites.append(ImageRawFrame(image=img.tobytes(), size=img.size, format=img.format))
 
 flipped = sprites[::-1]
 sprites.extend(flipped)
@@ -56,7 +56,7 @@ talking_frame = SpriteFrame(images=sprites)
 class TalkingAnimation(FrameProcessor):
     """
     This class starts a talking animation when it receives an first AudioFrame,
-    and then returns to a "quiet" sprite when it sees a LLMResponseEndFrame.
+    and then returns to a "quiet" sprite when it sees a TTSStoppedFrame.
     """
 
     def __init__(self):
@@ -82,11 +82,12 @@ async def main(room_url: str, token):
             token,
             "Chatbot",
             DailyParams(
-                audio_in_enabled=True,
                 audio_out_enabled=True,
                 camera_out_enabled=True,
                 camera_out_width=1024,
                 camera_out_height=576,
+                vad_enabled=True,
+                vad_analyzer=SileroVADAnalyzer(),
                 transcription_enabled=True,
                 #
                 # Spanish
@@ -99,8 +100,6 @@ async def main(room_url: str, token):
             )
         )
 
-        vad = SileroVAD()
-
         tts = ElevenLabsTTSService(
             aiohttp_session=session,
             api_key=os.getenv("ELEVENLABS_API_KEY"),
@@ -136,13 +135,21 @@ async def main(room_url: str, token):
         ]
 
         user_response = LLMUserResponseAggregator()
+        assistant_response = LLMAssistantResponseAggregator()
 
         ta = TalkingAnimation()
 
-        pipeline = Pipeline([transport.input(), vad, user_response,
-                            llm, tts, ta, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            user_response,
+            llm,
+            tts,
+            ta,
+            transport.output(),
+            assistant_response,
+        ])
 
-        task = PipelineTask(pipeline)
+        task = PipelineTask(pipeline, PipelineParams(allow_interruptions=True))
         await task.queue_frame(quiet_frame)
 
         @transport.event_handler("on_first_participant_joined")
@@ -156,9 +163,5 @@ async def main(room_url: str, token):
 
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Daily Storyteller Bot")
-    parser.add_argument("-u", type=str, help="Room URL")
-    parser.add_argument("-t", type=str, help="Token")
-    config = parser.parse_args()
-
-    asyncio.run(main(config.u, config.t))
+    (url, token) = configure()
+    asyncio.run(main(url, token))

examples/simple-chatbot/bot_runner.py

@@ -1,169 +0,0 @@
-from daily_helpers import create_room, get_token, check_room_url
-import os
-import argparse
-import subprocess
-import atexit
-from pathlib import Path
-from typing import Optional
-
-from fastapi import FastAPI, Request, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse, JSONResponse
-
-from dotenv import load_dotenv
-load_dotenv(override=True)
-
-# Bot sub-process dict for status reporting and concurrency control
-bot_procs = {}
-
-
-def cleanup():
-    # Clean up function, just to be extra safe
-    for proc in bot_procs.values():
-        proc[0].terminate()
-        proc[0].wait()
-
-
-atexit.register(cleanup)
-
-# ------------ Configuration ------------ #
-
-MAX_SESSION_TIME = + 5 * 60  # 5 minutes
-BOT_CAN_IDLE = True
-SERVE_STATIC = True
-STATIC_DIR = "../web-ui/dist"
-STATIC_ROUTE = "/static"
-STATIC_INDEX = "index.html"
-USE_OPEN_MIC = True  # Can the user freely talk, or do they need to wait their turn?
-
-# ----------------- API ----------------- #
-
-app = FastAPI()
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"]
-)
-
-# Optionally serve client static files
-if SERVE_STATIC:
-    app.mount(STATIC_ROUTE, StaticFiles(
-        directory=STATIC_DIR, html=True), name="static")
-
-    @app.get("/{path_name:path}", response_class=FileResponse)
-    async def catch_all(path_name: Optional[str] = ""):
-        if path_name == "":
-            return FileResponse(f"{STATIC_DIR}/{STATIC_INDEX}")
-
-        file_path = Path(STATIC_DIR) / (path_name or "")
-
-        if file_path.is_file():
-            return file_path
-
-        html_file_path = file_path.with_suffix(".html")
-        if html_file_path.is_file():
-            return FileResponse(html_file_path)
-
-        raise HTTPException(
-            status_code=404, detail="Page not found")
-
-
-@app.post("/start_bot")
-async def start_bot(request: Request) -> JSONResponse:
-    try:
-        data = await request.json()
-        # Is this a webhook creation request?
-        if "test" in data:
-            return JSONResponse({"test": True})
-    except Exception:
-        pass
-
-    # Use specified room URL, or create a new one if not specified
-    room_url = os.getenv("DAILY_SAMPLE_ROOM_URL", None)
-
-    if not room_url:
-        try:
-            room_url = create_room(MAX_SESSION_TIME)
-        except Exception:
-            raise HTTPException(
-                status_code=500,
-                detail="Unable to provision room")
-    else:
-        # Check passed room URL exists
-        try:
-            check_room_url(room_url)
-        except Exception:
-            raise HTTPException(
-                status_code=500, detail=f"Room not found: {room_url}")
-
-    # Give the agent a token to join the session
-    token = get_token(room_url)
-
-    if not room_url or not token:
-        raise HTTPException(
-            status_code=500, detail=f"Failed to get token for room: {room_url}")
-
-    # Spawn a new agent, and join the user session
-    # Note: this is mostly for demonstration purposes (refer to 'deployment' in README)
-
-    # @TODO: Spawn a new fly machine here...
-    try:
-        proc = subprocess.Popen(
-            [
-                f"python3 -m bot -u {room_url} -t {token}"
-            ],
-            shell=True,
-            bufsize=1,
-            cwd=os.path.dirname(os.path.abspath(__file__))
-        )
-        bot_procs[proc.pid] = (proc, room_url)
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, detail=f"Failed to start subprocess: {e}")
-
-     # Grab a token for the user to join with
-    user_token = get_token(room_url)
-
-    return JSONResponse({
-        "bot_id": proc.pid,
-        "room_url": room_url,
-        "token": user_token,
-        "config": {"open_mic": USE_OPEN_MIC}})
-
-
-# ----------------- Main ----------------- #
-
-if __name__ == "__main__":
-    # Check environment variables
-    required_env_vars = ['OPENAI_API_KEY', 'DAILY_API_KEY',
-                         'ELEVENLABS_VOICE_ID', 'ELEVENLABS_API_KEY']
-    for env_var in required_env_vars:
-        if env_var not in os.environ:
-            raise Exception(f"Missing environment variable: {env_var}.")
-
-    parser = argparse.ArgumentParser(description="Pipecat Bot Runner")
-    parser.add_argument("--host", type=str,
-                        default=os.getenv("HOST", "localhost"), help="Host address")
-    parser.add_argument("--port", type=int,
-                        default=os.getenv("PORT", 7860), help="Port number")
-    parser.add_argument("--reload", action="store_true",
-                        default=True, help="Reload code on change")
-
-    config = parser.parse_args()
-
-    try:
-        import uvicorn
-
-        uvicorn.run(
-            "bot_runner:app",
-            host=config.host,
-            port=config.port,
-            reload=config.reload
-        )
-
-    except KeyboardInterrupt:
-        print("Pipecat runner shutting down...")

examples/simple-chatbot/requirements.txt

@@ -1,7 +1,5 @@
-pipecat-ai[daily,openai,fal]
-fastapi
-uvicorn
-requests
 python-dotenv
-loguru
-requests
+requests
+fastapi[all]
+uvicorn
+pipecat-ai[daily,openai,silero]

examples/simple-chatbot/runner.py

@@ -0,0 +1,58 @@
+import argparse
+import os
+import time
+import urllib
+import requests
+
+
+def configure():
+    parser = argparse.ArgumentParser(description="Daily AI SDK Bot Sample")
+    parser.add_argument(
+        "-u",
+        "--url",
+        type=str,
+        required=False,
+        help="URL of the Daily room to join")
+    parser.add_argument(
+        "-k",
+        "--apikey",
+        type=str,
+        required=False,
+        help="Daily API Key (needed to create an owner token for the room)",
+    )
+
+    args, unknown = parser.parse_known_args()
+
+    url = args.url or os.getenv("DAILY_SAMPLE_ROOM_URL")
+    key = args.apikey or os.getenv("DAILY_API_KEY")
+
+    if not url:
+        raise Exception(
+            "No Daily room specified. use the -u/--url option from the command line, or set DAILY_SAMPLE_ROOM_URL in your environment to specify a Daily room URL.")
+
+    if not key:
+        raise Exception("No Daily API key specified. use the -k/--apikey option from the command line, or set DAILY_API_KEY in your environment to specify a Daily API key, available from https://dashboard.daily.co/developers.")
+
+    # Create a meeting token for the given room with an expiration 1 hour in
+    # the future.
+    room_name: str = urllib.parse.urlparse(url).path[1:]
+    expiration: float = time.time() + 60 * 60
+
+    res: requests.Response = requests.post(
+        f"https://api.daily.co/v1/meeting-tokens",
+        headers={
+            "Authorization": f"Bearer {key}"},
+        json={
+            "properties": {
+                "room_name": room_name,
+                "is_owner": True,
+                "exp": expiration}},
+    )
+
+    if res.status_code != 200:
+        raise Exception(
+            f"Failed to create meeting token: {res.status_code} {res.text}")
+
+    token: str = res.json()["token"]
+
+    return (url, token)

examples/simple-chatbot/server.py

@@ -0,0 +1,124 @@
+import os
+import argparse
+import subprocess
+import atexit
+
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, RedirectResponse
+
+from utils.daily_helpers import create_room as _create_room, get_token
+
+MAX_BOTS_PER_ROOM = 1
+
+# Bot sub-process dict for status reporting and concurrency control
+bot_procs = {}
+
+
+def cleanup():
+    # Clean up function, just to be extra safe
+    for proc in bot_procs.values():
+        proc.terminate()
+        proc.wait()
+
+
+atexit.register(cleanup)
+
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/start")
+async def start_agent(request: Request):
+    print(f"!!! Creating room")
+    room_url, room_name = _create_room()
+    print(f"!!! Room URL: {room_url}")
+    # Ensure the room property is present
+    if not room_url:
+        raise HTTPException(
+            status_code=500,
+            detail="Missing 'room' property in request data. Cannot start agent without a target room!")
+
+    # Check if there is already an existing process running in this room
+    num_bots_in_room = sum(
+        1 for proc in bot_procs.values() if proc[1] == room_url and proc[0].poll() is None)
+    if num_bots_in_room >= MAX_BOTS_PER_ROOM:
+        raise HTTPException(
+            status_code=500, detail=f"Max bot limited reach for room: {room_url}")
+
+    # Get the token for the room
+    token = get_token(room_url)
+
+    if not token:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to get token for room: {room_url}")
+
+    # Spawn a new agent, and join the user session
+    # Note: this is mostly for demonstration purposes (refer to 'deployment' in README)
+    try:
+        proc = subprocess.Popen(
+            [
+                f"python3 -m bot -u {room_url} -t {token}"
+            ],
+            shell=True,
+            bufsize=1,
+            cwd=os.path.dirname(os.path.abspath(__file__))
+        )
+        bot_procs[proc.pid] = (proc, room_url)
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to start subprocess: {e}")
+
+    return RedirectResponse(room_url)
+
+
+@app.get("/status/{pid}")
+def get_status(pid: int):
+    # Look up the subprocess
+    proc = bot_procs.get(pid)
+
+    # If the subprocess doesn't exist, return an error
+    if not proc:
+        raise HTTPException(
+            status_code=404, detail=f"Bot with process id: {pid} not found")
+
+    # Check the status of the subprocess
+    if proc[0].poll() is None:
+        status = "running"
+    else:
+        status = "finished"
+
+    return JSONResponse({"bot_id": pid, "status": status})
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    default_host = os.getenv("HOST", "0.0.0.0")
+    default_port = int(os.getenv("FAST_API_PORT", "7860"))
+
+    parser = argparse.ArgumentParser(
+        description="Daily Storyteller FastAPI server")
+    parser.add_argument("--host", type=str,
+                        default=default_host, help="Host address")
+    parser.add_argument("--port", type=int,
+                        default=default_port, help="Port number")
+    parser.add_argument("--reload", action="store_true",
+                        help="Reload code on change")
+
+    config = parser.parse_args()
+
+    uvicorn.run(
+        "server:app",
+        host=config.host,
+        port=config.port,
+        reload=config.reload,
+    )

examples/simple-chatbot/utils/daily_helpers.py

@@ -0,0 +1,109 @@
+
+import urllib.parse
+import os
+import time
+import urllib
+import requests
+
+from dotenv import load_dotenv
+load_dotenv()
+
+
+daily_api_path = os.getenv("DAILY_API_URL") or "api.daily.co/v1"
+daily_api_key = os.getenv("DAILY_API_KEY")
+
+
+def create_room() -> tuple[str, str]:
+    """
+    Helper function to create a Daily room.
+    # See: https://docs.daily.co/reference/rest-api/rooms
+
+    Returns:
+        tuple: A tuple containing the room URL and room name.
+
+    Raises:
+        Exception: If the request to create the room fails or if the response does not contain the room URL or room name.
+    """
+    room_props = {
+        "exp": time.time() + 60 * 60,  # 1 hour
+        "enable_chat": True,
+        "enable_emoji_reactions": True,
+        "eject_at_room_exp": True,
+        "enable_prejoin_ui": False,  # Important for the bot to be able to join headlessly
+    }
+    res = requests.post(
+        f"https://{daily_api_path}/rooms",
+        headers={"Authorization": f"Bearer {daily_api_key}"},
+        json={
+            "properties": room_props
+        },
+    )
+    if res.status_code != 200:
+        raise Exception(f"Unable to create room: {res.text}")
+
+    data = res.json()
+    room_url: str = data.get("url")
+    room_name: str = data.get("name")
+    if room_url is None or room_name is None:
+        raise Exception("Missing room URL or room name in response")
+
+    return room_url, room_name
+
+
+def get_name_from_url(room_url: str) -> str:
+    """
+    Extracts the name from a given room URL.
+
+    Args:
+        room_url (str): The URL of the room.
+
+    Returns:
+        str: The extracted name from the room URL.
+    """
+    return urllib.parse.urlparse(room_url).path[1:]
+
+
+def get_token(room_url: str) -> str:
+    """
+    Retrieves a meeting token for the specified Daily room URL.
+    # See: https://docs.daily.co/reference/rest-api/meeting-tokens
+
+    Args:
+        room_url (str): The URL of the Daily room.
+
+    Returns:
+        str: The meeting token.
+
+    Raises:
+        Exception: If no room URL is specified or if no Daily API key is specified.
+        Exception: If there is an error creating the meeting token.
+    """
+    if not room_url:
+        raise Exception(
+            "No Daily room specified. You must specify a Daily room in order a token to be generated.")
+
+    if not daily_api_key:
+        raise Exception(
+            "No Daily API key specified. set DAILY_API_KEY in your environment to specify a Daily API key, available from https://dashboard.daily.co/developers.")
+
+    expiration: float = time.time() + 60 * 60
+    room_name = get_name_from_url(room_url)
+
+    res: requests.Response = requests.post(
+        f"https://{daily_api_path}/meeting-tokens",
+        headers={
+            "Authorization": f"Bearer {daily_api_key}"},
+        json={
+            "properties": {
+                "room_name": room_name,
+                "is_owner": True,  # Owner tokens required for transcription
+                "exp": expiration}},
+    )
+
+    if res.status_code != 200:
+        raise Exception(
+            f"Failed to create meeting token: {res.status_code} {res.text}")
+
+    token: str = res.json()["token"]
+
+    return token

examples/storytelling-chatbot/README.md

@@ -37,6 +37,8 @@ Adds pictures to our story (really fast!) Prompting is quite key for style consi
 **Install requirements**
 
 ```shell
+python3 -m venv venv
+source venv/bin/activate
 pip install -r requirements.txt
 ```
 
@@ -52,7 +54,7 @@ This project uses a custom frontend, which needs to built. Note: this is done au
 
 ```shell
 cd frontend/
-npm install / yarn
+npm install
 npm run build
 ```
 
@@ -68,12 +70,7 @@ If you'd like to run a custom domain or port:
 
 `python src/server.py --host somehost --p 7777`
 
-➡️ Open the host URL in your browser
-
-> [!IMPORTANT]
-> Whilst working on the frontend code, please `yarn run dev`
-> and open the NextJS hosted service vs. the Python server.
-> (Usually localhost:3000.)
+➡️ Open the host URL in your browser `http://localhost:7860`
 
 ---
 

examples/storytelling-chatbot/src/bot.py

@@ -133,8 +133,8 @@ async def main(room_url, token=None):
             story_processor,
             image_processor,
             tts_service,
-            llm_responses,
-            transport.output()
+            transport.output(),
+            llm_responses
         ])
 
         main_task = PipelineTask(main_pipeline)

examples/storytelling-chatbot/src/processors.py

@@ -2,7 +2,11 @@ import re
 
 from async_timeout import timeout
 
-from pipecat.frames.frames import Frame, LLMResponseEndFrame, TextFrame, UserStoppedSpeakingFrame
+from pipecat.frames.frames import (
+    Frame,
+    LLMFullResponseEndFrame,
+    TextFrame,
+    UserStoppedSpeakingFrame)
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.transports.services.daily import DailyTransportMessageFrame
 
@@ -128,9 +132,9 @@ class StoryProcessor(FrameProcessor):
                 # Clear the buffer
                 self._text = ""
 
-        # End of LLM response
+        # End of a full LLM response
         # Driven by the prompt, the LLM should have asked the user for input
-        elif isinstance(frame, LLMResponseEndFrame):
+        elif isinstance(frame, LLMFullResponseEndFrame):
             # We use a different frame type, as to avoid image generation ingest
             await self.push_frame(StoryPromptFrame(self._text))
             self._text = ""

examples/translation-chatbot/bot.py

@@ -3,7 +3,7 @@ import aiohttp
 import os
 import sys
 
-from pipecat.frames.frames import Frame, InterimTranscriptionFrame, LLMMessagesFrame, TextFrame, TranscriptionFrame, TransportMessageFrame
+from pipecat.frames.frames import Frame, LLMMessagesFrame, TextFrame
 from pipecat.pipeline.pipeline import Pipeline
 from pipecat.pipeline.runner import PipelineRunner
 from pipecat.pipeline.task import PipelineTask
@@ -12,7 +12,7 @@ from pipecat.processors.aggregators.sentence import SentenceAggregator
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.services.azure import AzureTTSService
 from pipecat.services.openai import OpenAILLMService
-from pipecat.transports.services.daily import DailyParams, DailyTransport, DailyTransportMessageFrame
+from pipecat.transports.services.daily import DailyParams, DailyTranscriptionSettings, DailyTransport, DailyTransportMessageFrame
 
 from runner import configure
 
@@ -84,7 +84,9 @@ async def main(room_url: str, token):
             DailyParams(
                 audio_out_enabled=True,
                 transcription_enabled=True,
-                transcription_interim_results=False,
+                transcription_settings=DailyTranscriptionSettings(extra={
+                    "interim_results": False
+                })
             )
         )
 
@@ -103,7 +105,16 @@ async def main(room_url: str, token):
         lfra = LLMFullResponseAggregator()
         ts = TranslationSubtitles("spanish")
 
-        pipeline = Pipeline([transport.input(), sa, tp, llm, lfra, ts, tts, transport.output()])
+        pipeline = Pipeline([
+            transport.input(),
+            sa,
+            tp,
+            llm,
+            lfra,
+            ts,
+            tts,
+            transport.output()
+        ])
 
         task = PipelineTask(pipeline)
 

examples/web-ui/.eslintrc.cjs

@@ -1,18 +0,0 @@
-module.exports = {
-  root: true,
-  env: { browser: true, es2020: true },
-  extends: [
-    'eslint:recommended',
-    'plugin:@typescript-eslint/recommended',
-    'plugin:react-hooks/recommended',
-  ],
-  ignorePatterns: ['dist', '.eslintrc.cjs'],
-  parser: '@typescript-eslint/parser',
-  plugins: ['react-refresh'],
-  rules: {
-    'react-refresh/only-export-components': [
-      'warn',
-      { allowConstantExport: true },
-    ],
-  },
-}

examples/web-ui/.gitignore

@@ -1,24 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
-
-node_modules
-dist
-dist-ssr
-*.local
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?

examples/web-ui/README.md

@@ -1,30 +0,0 @@
-# React + TypeScript + Vite
-
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
-
-Currently, two official plugins are available:
-
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
-
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
-
-- Configure the top-level `parserOptions` property like this:
-
-```js
-export default {
-  // other rules...
-  parserOptions: {
-    ecmaVersion: 'latest',
-    sourceType: 'module',
-    project: ['./tsconfig.json', './tsconfig.node.json'],
-    tsconfigRootDir: __dirname,
-  },
-}
-```
-
-- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
-- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
-- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list

examples/web-ui/env.example

@@ -1 +0,0 @@
-VITE_SERVER_URL=... #optional: if serving frontend independetely from backend (otherwise relative.)

examples/web-ui/index.html

@@ -1,17 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/favicon.ico" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&family=Space+Mono:wght@400;700&display=swap" rel="stylesheet">
-
-    <title>Pipecat Demo</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>

examples/web-ui/package.json

@@ -1,36 +0,0 @@
-{
-  "name": "pipecatdemo",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "tsc && vite build",
-    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "@daily-co/daily-js": "^0.64.0",
-    "@daily-co/daily-react": "^0.19.0",
-    "class-variance-authority": "^0.7.0",
-    "lucide-react": "^0.378.0",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "recoil": "^0.7.7"
-  },
-  "devDependencies": {
-    "@types/react": "^18.2.66",
-    "@types/react-dom": "^18.2.22",
-    "@typescript-eslint/eslint-plugin": "^7.2.0",
-    "@typescript-eslint/parser": "^7.2.0",
-    "@vitejs/plugin-react": "^4.2.1",
-    "eslint": "^8.57.0",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "eslint-plugin-react-refresh": "^0.4.6",
-    "i": "^0.3.7",
-    "npm": "^10.8.0",
-    "typescript": "^5.2.2",
-    "vite": "^5.2.0",
-    "vite-plugin-webfont-dl": "^3.9.4"
-  }
-}

examples/web-ui/src/App.tsx

@@ -1,141 +0,0 @@
-import { useState } from "react";
-import { useDaily } from "@daily-co/daily-react";
-
-import { Alert } from "./components/alert";
-import { Button } from "./components/button";
-import { ArrowRight, Loader2 } from "lucide-react";
-import { DeviceSelect } from "./components/DeviceSelect";
-import Session from "./components/Session";
-
-type State =
-  | "idle"
-  | "configuring"
-  | "requesting_agent"
-  | "connecting"
-  | "connected"
-  | "started"
-  | "finished"
-  | "error";
-
-export default function App() {
-  // Use Daily as our agent transport
-  const daily = useDaily();
-
-  const [state, setState] = useState<State>("idle");
-  const [error, setError] = useState<string | null>(null);
-  const [config, setConfig] = useState<{ open_mic?: boolean }>({});
-
-  async function start() {
-    if (!daily) return;
-
-    setState("requesting_agent");
-
-    const serverUrl =
-      import.meta.env.VITE_SERVER_URL || import.meta.env.BASE_URL;
-
-    // Request a bot to join your session
-    let data;
-
-    try {
-      const res = await fetch(`${serverUrl}start_bot`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-        },
-      });
-
-      data = await res.json();
-      setConfig(data.config || {});
-
-      if (!res.ok) {
-        setError(data.detail);
-        setState("error");
-        return;
-      }
-    } catch (e) {
-      setError(
-        `Unable to connect to the server at '${serverUrl}' - is it running?`
-      );
-      setState("error");
-      return;
-    }
-
-    setState("connecting");
-
-    await daily.join({
-      url: data.room_url,
-      token: data.token,
-      videoSource: false,
-      startAudioOff: true,
-    });
-
-    setState("connected");
-  }
-
-  async function leave() {
-    await daily?.leave();
-    setState("idle");
-  }
-
-  if (state === "error") {
-    return (
-      <Alert intent="danger" title="An error occurred">
-        {error}
-      </Alert>
-    );
-  }
-
-  if (state === "connected") {
-    return <Session onLeave={() => leave()} openMic={config?.open_mic} />;
-  }
-
-  const status_text = {
-    configuring: "Start",
-    requesting_agent: "Requesting agent...",
-    connecting: "Connecting to agent...",
-  };
-
-  if (state !== "idle") {
-    return (
-      <div className="card card-appear">
-        <div className="card-inner">
-          <h1 className="card-header">Configure your devices</h1>
-          <p className="card-text">
-            Please configure your microphone and speakers below
-          </p>
-          <DeviceSelect />
-          <Button
-            key="start"
-            onClick={() => start()}
-            disabled={state !== "configuring"}
-          >
-            {state !== "configuring" && <Loader2 className="animate-spin" />}
-            {status_text[state as keyof typeof status_text]}
-          </Button>
-        </div>
-      </div>
-    );
-  }
-
-  return (
-    <div className="card card-appear">
-      <div className="card-inner">
-        <h1 className="card-header">Pipecat Simple Chatbot</h1>
-        <p className="card-text">
-          Please ensure you microphone and speakers are connected and ready to
-          go
-        </p>
-        {import.meta.env.DEV && !import.meta.env.VITE_SERVER_URL && (
-          <div>
-            Warning: you have not set a server URL for local development. Please
-            set <code>VITE_SERVER_URL</code> in{" "}
-            <code>.env.development.local</code>
-          </div>
-        )}
-        <Button key="next" onClick={() => setState("configuring")}>
-          Next <ArrowRight />
-        </Button>
-      </div>
-    </div>
-  );
-}

examples/web-ui/src/assets/logo.svg

@@ -1,7 +0,0 @@
-<svg width="332" height="192" viewBox="0 0 332 192" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M45.7718 0.769635C50.4477 -0.990844 55.7252 0.330188 59.0204 4.08595L101.936 53H230.064L272.98 4.08595C276.275 0.330188 281.552 -0.990844 286.228 0.769635C290.904 2.53011 294 7.00367 294 12V120H332V144H270V43.8728L244.52 72.9141C242.242 75.5111 238.955 77 235.5 77H96.5C93.0452 77 89.7581 75.5111 87.4796 72.9141L62 43.8728V144H0V120H38V12C38 7.00367 41.0958 2.53011 45.7718 0.769635Z" fill="black"/>
-<path d="M270 168H332V192H270V168Z" fill="black"/>
-<path d="M0 168H62V192H0V168Z" fill="black"/>
-<path d="M128 128C128 136.837 120.837 144 112 144C103.163 144 96 136.837 96 128C96 119.164 103.163 112 112 112C120.837 112 128 119.164 128 128Z" fill="black"/>
-<path d="M236 128C236 136.837 228.837 144 220 144C211.163 144 204 136.837 204 128C204 119.164 211.163 112 220 112C228.837 112 236 119.164 236 128Z" fill="black"/>
-</svg>

examples/web-ui/src/components/AudioIndicator/index.tsx

@@ -1,31 +0,0 @@
-import {
-  useAudioLevel,
-  useAudioTrack,
-  useLocalSessionId,
-} from "@daily-co/daily-react";
-import { useCallback, useRef } from "react";
-
-import styles from "./styles.module.css";
-
-export const AudioIndicatorBar: React.FC = () => {
-  const localSessionId = useLocalSessionId();
-  const audioTrack = useAudioTrack(localSessionId);
-
-  const volRef = useRef<HTMLDivElement>(null);
-
-  useAudioLevel(
-    audioTrack?.persistentTrack,
-    useCallback((volume) => {
-      if (volRef.current)
-        volRef.current.style.width = Math.max(2, volume * 100) + "%";
-    }, [])
-  );
-
-  return (
-    <div className={styles.bar}>
-      <div ref={volRef} />
-    </div>
-  );
-};
-
-export default AudioIndicatorBar;

examples/web-ui/src/components/AudioIndicator/styles.module.css

@@ -1,15 +0,0 @@
-.bar {
-  background: var(--color-gray-200);
-  height: 8px;
-  width: 100%;
-  border-radius: 999px;
-  overflow: hidden;
-
-  > div {
-    background: var(--color-green-500);
-    height: 8px;
-    width: 0px;
-    border-radius: 999px;
-    transition: width 0.1s ease;
-  }
-}

examples/web-ui/src/components/DeviceSelect/index.tsx

@@ -1,127 +0,0 @@
-"use client";
-
-import { useEffect } from "react";
-import { DailyMeetingState } from "@daily-co/daily-js";
-import { useDaily, useDevices } from "@daily-co/daily-react";
-import { Mic, Speaker } from "lucide-react";
-import { AudioIndicatorBar } from "../AudioIndicator";
-
-import styles from "./styles.module.css";
-import { Alert } from "../alert";
-
-export function DeviceSelect() {
-  const daily = useDaily();
-  const {
-    currentMic,
-    hasMicError,
-    micState,
-    microphones,
-    setMicrophone,
-    currentSpeaker,
-    speakers,
-    setSpeaker,
-  } = useDevices();
-
-  const handleMicrophoneChange = (value: string) => {
-    setMicrophone(value);
-  };
-
-  const handleSpeakerChange = (value: string) => {
-    setSpeaker(value);
-  };
-
-  useEffect(() => {
-    if (microphones.length > 0 || !daily || daily.isDestroyed()) return;
-    const meetingState = daily.meetingState();
-    const meetingStatesBeforeJoin: DailyMeetingState[] = [
-      "new",
-      "loading",
-      "loaded",
-    ];
-    if (meetingStatesBeforeJoin.includes(meetingState)) {
-      daily.startCamera({ startVideoOff: true, startAudioOff: false });
-    }
-  }, [daily, microphones]);
-
-  return (
-    <div className={styles.deviceSelect}>
-      {hasMicError && (
-        <Alert intent="danger" title="Device error">
-          {micState === "blocked" ? (
-            <>
-              Please check your browser and system permissions. Make sure that
-              this app is allowed to access your microphone and refresh the
-              page.
-            </>
-          ) : micState === "in-use" ? (
-            <>
-              Your microphone is being used by another app. Please close any
-              other apps using your microphone and restart this app.
-            </>
-          ) : micState === "not-found" ? (
-            <>
-              No microphone seems to be connected. Please connect a microphone.
-            </>
-          ) : micState === "not-supported" ? (
-            <>
-              This app is not supported on your device. Please update your
-              software or use a different device.
-            </>
-          ) : (
-            <>
-              There seems to be an issue accessing your microphone. Try
-              restarting the app or consult a system administrator.
-            </>
-          )}
-        </Alert>
-      )}
-
-      <section className={styles.field}>
-        <label className={styles.label}>Microphone:</label>
-        <div className={styles.selectContainer}>
-          <Mic size={24} />
-          <select
-            onChange={(e) => handleMicrophoneChange(e.target.value)}
-            defaultValue={currentMic?.device.deviceId}
-            className={styles.deviceSelectField}
-          >
-            {microphones.length === 0 ? (
-              <option value="">Loading devices...</option>
-            ) : (
-              microphones.map((m) => (
-                <option key={m.device.deviceId} value={m.device.deviceId}>
-                  {m.device.label}
-                </option>
-              ))
-            )}
-          </select>
-        </div>
-        <AudioIndicatorBar />
-      </section>
-
-      <section className={styles.field}>
-        <label className={styles.label}>Speakers:</label>
-        <div className={styles.selectContainer}>
-          <Speaker size={24} />
-          <select
-            onChange={(e) => handleSpeakerChange(e.target.value)}
-            defaultValue={currentSpeaker?.device.deviceId}
-            className={styles.deviceSelectField}
-          >
-            {speakers.length === 0 ? (
-              <option value="">Loading devices...</option>
-            ) : (
-              speakers.map((m) => (
-                <option key={m.device.deviceId} value={m.device.deviceId}>
-                  {m.device.label}
-                </option>
-              ))
-            )}
-          </select>
-        </div>
-      </section>
-    </div>
-  );
-}
-
-export default DeviceSelect;

examples/web-ui/src/components/DeviceSelect/styles.module.css

@@ -1,39 +0,0 @@
-.deviceSelect {
-  display: flex;
-  flex-flow: column wrap;
-  width: 100%;
-  gap: 1rem;
-}
-
-.field {
-  display: flex;
-  flex-flow: column wrap;
-  align-items: flex-start;
-  gap: 0.5rem;
-}
-
-.label {
-  font-weight: 600;
-  font-size: 0.875rem;
-}
-
-.selectContainer {
-  position: relative;
-  width: 100%;
-
-  > svg {
-    position: absolute;
-    size: 24px;
-    top: 0;
-    bottom: 0;
-    margin: auto 0;
-    left: 0.75rem;
-    color: var(--color-gray-400);
-  }
-}
-
-.deviceSelectField {
-  width: 100%;
-  padding-left: 2.875rem;
-  margin-top: auto;
-}

examples/web-ui/src/components/Session/agent.tsx

@@ -1,22 +0,0 @@
-import React from "react";
-import Status from "./status";
-import styles from "./styles.module.css";
-
-import { useParticipantIds } from "@daily-co/daily-react";
-
-export const Agent: React.FC = () => {
-  const participantIds = useParticipantIds({ filter: "remote" });
-
-  const status = participantIds.length > 0 ? "connected" : "connecting";
-  return (
-    <div className={styles.agent}>
-      <div className={styles.agentWindow}></div>
-      <footer className={styles.agentFooter}>
-        <Status>User status</Status>
-        <Status variant={status}>Agent status</Status>
-      </footer>
-    </div>
-  );
-};
-
-export default Agent;

examples/web-ui/src/components/Session/index.tsx

@@ -1,88 +0,0 @@
-import React, { useEffect, useRef, useState } from "react";
-import { LogOut, Settings } from "lucide-react";
-import { DailyAudio, useAppMessage, useDaily } from "@daily-co/daily-react";
-
-import DeviceSelect from "../DeviceSelect";
-import Agent from "./agent";
-import { Button } from "../button";
-import UserMicBubble from "../UserMicBubble";
-
-import styles from "./styles.module.css";
-
-interface SessionProps {
-  onLeave: () => void;
-  openMic?: boolean;
-}
-
-export const Session: React.FC<SessionProps> = ({
-  onLeave,
-  openMic = false,
-}) => {
-  const daily = useDaily();
-  const [showDevices, setShowDevices] = useState(false);
-  const modalRef = useRef<HTMLDialogElement>(null);
-  const [talkState, setTalkState] = useState<"user" | "assistant" | "open">(
-    openMic ? "open" : "assistant"
-  );
-
-  useAppMessage({
-    onAppMessage: (e) => {
-      if (!daily || !e.data?.cue) return;
-
-      // Determine the UI state from the cue sent by the bot
-      if (e.data?.cue === "user_turn") {
-        // Delay enabling local mic input to avoid feedback from LLM
-        setTimeout(() => daily.setLocalAudio(true), 500);
-        setTalkState("user");
-      } else {
-        daily.setLocalAudio(false);
-        setTalkState("assistant");
-      }
-    },
-  });
-
-  useEffect(() => {
-    const current = modalRef.current;
-    // Backdrop doesn't currently work with dialog open, so we use setModal instead
-    if (current && showDevices) {
-      current.inert = true;
-      current.showModal();
-      current.inert = false;
-    }
-    return () => current?.close();
-  }, [showDevices]);
-
-  return (
-    <>
-      <dialog ref={modalRef}>
-        <h2>Configure devices</h2>
-        <DeviceSelect />
-        <Button onClick={() => setShowDevices(false)}>Close</Button>
-      </dialog>
-
-      <div className={styles.agentContainer}>
-        <Agent />
-        <UserMicBubble openMic={openMic} active={talkState !== "assistant"} />
-        <DailyAudio />
-      </div>
-
-      <footer className={styles.footer}>
-        <div className={styles.controls}>
-          <Button
-            variant="ghost"
-            size="icon"
-            onClick={() => setShowDevices(true)}
-          >
-            <Settings />
-          </Button>
-          <Button onClick={() => onLeave()}>
-            <LogOut size={16} />
-            End
-          </Button>
-        </div>
-      </footer>
-    </>
-  );
-};
-
-export default Session;

examples/web-ui/src/components/Session/status.tsx

@@ -1,42 +0,0 @@
-import { VariantProps, cva } from "class-variance-authority";
-import styles from "./styles.module.css";
-
-const statusVariants = cva(styles.statusIndicator, {
-  variants: {
-    variant: {
-      default: styles.statusDefault,
-      connecting: styles.statusOrange,
-      connected: styles.statusGreen,
-    },
-  },
-  defaultVariants: {
-    variant: "default",
-  },
-});
-
-export interface StatusProps
-  extends React.HTMLAttributes<HTMLElement>,
-    VariantProps<typeof statusVariants> {}
-
-const status_text = {
-  default: "Idle",
-  connecting: "Connecting",
-  connected: "Connected",
-};
-
-export const Status: React.FC<StatusProps> = ({
-  children,
-  variant = "default",
-}) => {
-  return (
-    <div className={styles.status}>
-      <span>{children}</span>
-      <div className={statusVariants({ variant })}>
-        <span />
-        {status_text[variant as keyof typeof status_text]}
-      </div>
-    </div>
-  );
-};
-
-export default Status;

examples/web-ui/src/components/Session/styles.module.css

@@ -1,119 +0,0 @@
-.footer {
-  display: flex;
-  flex-flow: row nowrap;
-  margin-top: auto;
-  align-self: flex-end;
-}
-
-.controls {
-  display: flex;
-  flex-flow: row nowrap;
-  justify-content: space-between;
-  gap: 0.75rem;
-}
-
-.agentContainer {
-  flex: 1;
-  display: flex;
-  flex-flow: column wrap;
-  align-items: center;
-  justify-content: center;
-}
-
-.agent {
-  margin-top: auto;
-  min-width: 420px;
-  padding: 0.75rem;
-  border-radius: var(--borderRadius-lg);
-  border-radius: 24px;
-  border: 1px solid #e2e8f0;
-  background: #fff;
-  box-shadow: 0px 360px 101px 0px rgba(0, 0, 0, 0),
-    0px 231px 92px 0px rgba(0, 0, 0, 0), 0px 130px 78px 0px rgba(0, 0, 0, 0.02),
-    0px 58px 58px 0px rgba(0, 0, 0, 0.03), 0px 14px 32px 0px rgba(0, 0, 0, 0.03);
-  background-image: linear-gradient(90deg, white, white),
-    linear-gradient(0deg, var(--color-gray-300), var(--color-gray-200));
-  background-clip: padding-box, border-box;
-  background-origin: border-box;
-  border: 1px solid transparent;
-}
-
-.agentWindow {
-  min-width: 400px;
-  aspect-ratio: 1;
-  background: var(--color-gray-200);
-  border-radius: var(--borderRadius-md);
-}
-
-.agentFooter {
-  margin: 1.5rem 0 0.75rem 0;
-  display: flex;
-  flex-flow: row nowrap;
-  justify-content: space-between;
-  width: 100%;
-
-  > :first-child {
-    border-right: 1px solid var(--color-gray-200);
-  }
-}
-
-.status {
-  flex: 1;
-  line-height: 1;
-  display: flex;
-  flex-flow: column wrap;
-  align-items: center;
-  gap: 0.5rem;
-
-  > span {
-    font-family: var(--font-mono);
-    font-size: 11px;
-    text-transform: uppercase;
-    line-height: 1;
-    letter-spacing: 0.7px;
-  }
-}
-
-.statusIndicator {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-size: 0.75rem;
-  font-weight: 700;
-  padding: 0.5rem 0.75rem;
-  border-radius: var(--borderRadius-xs);
-
-  > span {
-    display: block;
-    width: 9px;
-    height: 9px;
-    border-radius: 9px;
-    background: red;
-  }
-}
-
-.statusDefault {
-  color: var(--color-gray-500);
-  background: var(--color-gray-100);
-
-  > span {
-    background: var(--color-gray-400);
-  }
-}
-.statusOrange {
-  color: var(--color-orange-800);
-  background: var(--color-orange-100);
-
-  > span {
-    background: var(--color-orange-400);
-  }
-}
-
-.statusGreen {
-  color: var(--color-green-800);
-  background: var(--color-green-100);
-
-  > span {
-    background: var(--color-green-400);
-  }
-}

examples/web-ui/src/components/UserMicBubble/index.tsx

@@ -1,71 +0,0 @@
-import React, { useCallback, useRef } from "react";
-
-import {
-  useAudioLevel,
-  useAudioTrack,
-  useLocalSessionId,
-  //useAppMessage,
-} from "@daily-co/daily-react";
-//import { DailyEventObjectAppMessage } from "@daily-co/daily-js";
-import { Mic, MicOff } from "lucide-react";
-//import { TypewriterEffect } from "../ui/typewriter";
-import styles from "./styles.module.css";
-
-const AudioIndicatorBubble: React.FC = () => {
-  const localSessionId = useLocalSessionId();
-  const audioTrack = useAudioTrack(localSessionId);
-  const volRef = useRef<HTMLDivElement>(null);
-
-  useAudioLevel(
-    audioTrack?.persistentTrack,
-    useCallback((volume) => {
-      // this volume number will be between 0 and 1
-      // give it a minimum scale of 0.15 to not completely disappear 👻
-      if (volRef.current) {
-        const v = volume * 1.75;
-        volRef.current.style.transform = `scale(${Math.max(0.1, v)})`;
-      }
-    }, [])
-  );
-
-  // Your audio track's audio volume visualized in a small circle,
-  // whose size changes depending on the volume level
-  return <div ref={volRef} className={styles.volume} />;
-};
-
-interface Props {
-  active: boolean;
-  openMic: boolean;
-}
-
-export default function UserMicBubble({ active, openMic = false }: Props) {
-  /*
-  const [transcription, setTranscription] = useState<string[]>([]);
-  useAppMessage({
-    onAppMessage: (e: DailyEventObjectAppMessage<any>) => {
-      if (e.fromId && e.fromId === "transcription") {
-        if (e.data.user_id === "" && e.data.is_final) {
-          //setTranscription((t) => [...t, ...e.data.text.split(" ")]);
-        }
-      }
-    },
-  });
-
-  useEffect(() => {
-    if (active) return;
-    const t = setTimeout(() => setTranscription([]), 4000);
-    return () => clearTimeout(t);
-  }, [active]);*/
-
-  const cx = openMic ? styles.micIconOpen : active && styles.micIconActive;
-
-  return (
-    <div className={`${styles.bubbleContainer}`}>
-      <div className={`${styles.micIcon} ${cx}`}>
-        {!openMic && !active ? <MicOff size={42} /> : <Mic size={42} />}
-        {(openMic || active) && <AudioIndicatorBubble />}
-      </div>
-      <footer className={styles.transcript}></footer>
-    </div>
-  );
-}

examples/web-ui/src/components/UserMicBubble/styles.module.css

@@ -1,103 +0,0 @@
-.bubbleContainer {
-  color: #ffffff;
-  position: relative;
-  z-index: 20;
-  display: flex;
-  flex-direction: column;
-  margin: auto;
-}
-
-.micIcon {
-  position: relative;
-  box-sizing: border-box;
-  -moz-box-sizing: border-box;
-  -webkit-box-sizing: border-box;
-  width: 120px;
-  height: 120px;
-  border-radius: 120px;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  margin: 0 auto;
-  z-index: 20;
-  transition: all 0.5s ease;
-  border: 6px solid color-mix(in srgb, var(--color-gray-300), transparent 70%);
-  outline: 6px solid color-mix(in srgb, var(--color-gray-300), transparent 70%);
-  background-color: var(--color-gray-500);
-  background-image: radial-gradient(
-    var(--color-gray-300),
-    var(--color-gray-400)
-  );
-}
-
-.micIcon svg {
-  position: relative;
-  z-index: 20;
-  opacity: 0.3;
-  transition: opacity 0.5s ease;
-}
-
-@keyframes pulse {
-  0% {
-    outline-width: 6px;
-    @apply outline-teal-500/10;
-  }
-  50% {
-    outline-width: 24px;
-    @apply outline-teal-500/50;
-  }
-  100% {
-    outline-width: 6px;
-    @apply outline-teal-500/10;
-  }
-}
-
-.micIconOpen {
-  background-color: var(--color-gray-500);
-  background-image: radial-gradient(
-    var(--color-gray-500),
-    var(--color-gray-600)
-  );
-  border: 6px solid color-mix(in srgb, var(--color-gray-200), transparent 60%);
-  outline: 6px solid color-mix(in srgb, var(--color-gray-400), transparent 70%);
-}
-
-.micIconActive {
-  background-color: var(--color-green-500);
-  background-image: radial-gradient(
-    var(--color-green-500),
-    var(--color-green-600)
-  );
-  border: 6px solid color-mix(in srgb, var(--color-green-200), transparent 60%);
-  outline: 6px solid color-mix(in srgb, var(--color-green-400), transparent 70%);
-  animation: pulse 2s infinite ease-in-out;
-}
-
-.micIconOpen svg,
-.micIconActive svg {
-  opacity: 1;
-}
-
-.transcript {
-  flex: 0;
-  align-self: center;
-  opacity: 0.25;
-  transition: opacity 1s ease;
-  transition-delay: 2.5s;
-}
-
-.active .transcript {
-  opacity: 1;
-}
-
-.volume {
-  position: absolute;
-  overflow: hidden;
-  inset: 0px;
-  z-index: 0;
-  border-radius: 999px;
-  transition: all 0.1s ease;
-  transform: scale(0);
-  opacity: 0.4;
-  background-color: var(--color-green-200);
-}

examples/web-ui/src/components/alert.tsx

@@ -1,27 +0,0 @@
-import React from "react";
-import { cva, VariantProps } from "class-variance-authority";
-
-const alertVariants = cva("alert", {
-  variants: {
-    intent: {
-      info: "alert-info",
-      danger: "alert-danger",
-    },
-  },
-  defaultVariants: {
-    intent: "info",
-  },
-});
-
-export interface AlertProps
-  extends React.HTMLAttributes<HTMLElement>,
-    VariantProps<typeof alertVariants> {}
-
-export const Alert: React.FC<AlertProps> = ({ children, intent, title }) => {
-  return (
-    <div className={alertVariants({ intent })}>
-      <span>{title}</span>
-      {children}
-    </div>
-  );
-};

examples/web-ui/src/components/button.tsx

@@ -1,27 +0,0 @@
-import React from "react";
-import { cva, VariantProps } from "class-variance-authority";
-
-const buttonVariants = cva("button", {
-  variants: {
-    variant: {
-      primary: "button-primary",
-      ghost: "button-ghost",
-    },
-    size: {
-      base: "",
-      icon: "button-icon",
-    },
-  },
-  defaultVariants: {
-    variant: "primary",
-    size: "base",
-  },
-});
-
-export interface ButtonProps
-  extends React.ButtonHTMLAttributes<HTMLButtonElement>,
-    VariantProps<typeof buttonVariants> {}
-
-export const Button: React.FC<ButtonProps> = ({ variant, size, ...props }) => {
-  return <button className={buttonVariants({ variant, size })} {...props} />;
-};

examples/web-ui/src/components/header.tsx

@@ -1,22 +0,0 @@
-import Logo from "./logo";
-
-function Header() {
-  return (
-    <header className="header">
-      <span className="logo-button">
-        <Logo />
-      </span>
-
-      <nav>
-        <a href="https://git.new/ai" target="_blank">
-          GitHub
-        </a>
-        <a href="https://discord.gg/pipecat" target="_blank">
-          Discord
-        </a>
-      </nav>
-    </header>
-  );
-}
-
-export default Header;

examples/web-ui/src/components/logo.tsx

@@ -1,46 +0,0 @@
-import React from "react";
-
-const Logo: React.FC = () => {
-  return (
-    <svg
-      width="332"
-      height="192"
-      viewBox="0 0 332 192"
-      fill="none"
-      xmlns="http://www.w3.org/2000/svg"
-      className="logo"
-    >
-      <path
-        d="M45.7718 0.769635C50.4477 -0.990844 55.7252 0.330188 59.0204 4.08595L101.936 53H230.064L272.98 4.08595C276.275 0.330188 281.552 -0.990844 286.228 0.769635C290.904 2.53011 294 7.00367 294 12V120H332V144H270V43.8728L244.52 72.9141C242.242 75.5111 238.955 77 235.5 77H96.5C93.0452 77 89.7581 75.5111 87.4796 72.9141L62 43.8728V144H0V120H38V12C38 7.00367 41.0958 2.53011 45.7718 0.769635Z"
-        fill="black"
-      />
-      <path d="M270 168H332V192H270V168Z" fill="black" />
-      <path d="M0 168H62V192H0V168Z" fill="black" />
-      <g id="eyes_1">
-        <path
-          d="M128 128C128 136.837 120.837 144 112 144C103.163 144 96 136.837 96 128C96 119.164 103.163 112 112 112C120.837 112 128 119.164 128 128Z"
-          fill="black"
-        />
-        <path
-          d="M236 128C236 136.837 228.837 144 220 144C211.163 144 204 136.837 204 128C204 119.164 211.163 112 220 112C228.837 112 236 119.164 236 128Z"
-          fill="black"
-        />
-      </g>
-
-      <g id="eyes_2" visibility="hidden">
-        <path
-          d="M128 128C128 136.837 120.837 144 112 144C103.163 144 96 136.837 96 128C96 119.163 103.163 112 112 112C120.837 112 128 119.163 128 128Z"
-          stroke="black"
-          strokeWidth="12"
-        />
-        <path
-          d="M236 128C236 136.837 228.837 144 220 144C211.163 144 204 136.837 204 128C204 119.163 211.163 112 220 112C228.837 112 236 119.163 236 128Z"
-          stroke="black"
-          strokeWidth="12"
-        />
-      </g>
-    </svg>
-  );
-};
-
-export default Logo;

examples/web-ui/src/global.css

@@ -1,387 +0,0 @@
-:root {
-  --color-gray-50: #f8fafc;
-  --color-gray-100: #f1f5f9;
-  --color-gray-200: #e2e8f0;
-  --color-gray-300: #cbd5e1;
-  --color-gray-400: #94a3b8;
-  --color-gray-500: #64748b;
-  --color-gray-600: #475569;
-  --color-gray-700: #334155;
-  --color-gray-800: #1e293b;
-  --color-gray-900: #0f172a;
-  --color-gray-950: #020617;
-
-  --color-orange-50: #fff7ed;
-  --color-orange-100: #ffedd5;
-  --color-orange-200: #fed7aa;
-  --color-orange-300: #fdba74;
-  --color-orange-400: #fb923c;
-  --color-orange-500: #f97316;
-  --color-orange-600: #ea580c;
-  --color-orange-700: #c2410c;
-  --color-orange-800: #9a3412;
-  --color-orange-900: #7c2d12;
-  --color-orange-950: #431407;
-
-  --color-green-50: #f0fdf4;
-  --color-green-100: #dcfce7;
-  --color-green-200: #bbf7d0;
-  --color-green-300: #86efac;
-  --color-green-400: #4ade80;
-  --color-green-500: #22c55e;
-  --color-green-600: #16a34a;
-  --color-green-700: #15803d;
-  --color-green-800: #166534;
-  --color-green-900: #14532d;
-  --color-green-950: #052e16;
-
-  --borderRadius-xs: 6px;
-  --borderRadius-sm: 9px;
-  --borderRadius-md: 12px;
-  --borderRadius-lg: 24px;
-  --input-height: 48px;
-
-  --font-sans: "Inter", system-ui, Avenir, Helvetica, Arial, sans-serif;
-  --font-mono: "Space Mono", monospace;
-
-  --font-size-base: 1rem;
-  --font-size-sm: 0.875rem;
-  --font-size-lg: 1.125rem;
-  --font-size-xl: 1.25rem;
-}
-
-* {
-  font-family: var(--font-sans);
-}
-
-#root {
-  line-height: 1.5;
-  font-weight: 400;
-
-  font-synthesis: none;
-  text-rendering: optimizeLegibility;
-  -webkit-font-smoothing: antialiased;
-  -moz-osx-font-smoothing: grayscale;
-
-  margin: 0 auto;
-  padding: 1rem;
-  text-align: center;
-  display: flex;
-  flex-direction: column;
-  flex: 1;
-}
-
-* {
-  outline-color: black;
-  outline-offset: 4px;
-}
-
-body {
-  margin: 0;
-  min-width: 320px;
-  min-height: 100vh;
-  display: flex;
-  color: var(--color-gray-950);
-  background-color: var(--color-gray-50);
-}
-
-a {
-  color: var(--color-gray-950);
-  text-decoration: inherit;
-}
-a:hover {
-  text-decoration-line: underline;
-}
-
-main {
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  flex: 1;
-}
-
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
-.header {
-  display: flex;
-  align-self: flex-start;
-  align-items: center;
-  gap: 2rem;
-}
-
-.header .logo-button {
-  box-sizing: border-box;
-  border: 1px solid var(--color-gray-200);
-  padding: 0.5rem;
-  display: flex;
-  place-items: center;
-  border-radius: var(--borderRadius-md);
-  transition: all 0.3s ease;
-  background: white;
-  box-shadow: 0px 7px 2px 0px rgba(0, 0, 0, 0),
-    0px 5px 2px 0px rgba(0, 0, 0, 0.01), 0px 3px 2px 0px rgba(0, 0, 0, 0.03),
-    0px 1px 1px 0px rgba(0, 0, 0, 0.04), 0px 0px 1px 0px rgba(0, 0, 0, 0.05);
-}
-
-.header .logo {
-  width: 42px;
-  height: auto;
-  aspect-ratio: 1;
-}
-
-.header nav {
-  pointer-events: none;
-  flex-flow: row nowrap;
-  align-items: center;
-  gap: 2rem;
-  display: none;
-
-  a {
-    font-size: 1.125rem;
-    line-height: 1.75rem;
-    text-underline-offset: 4px;
-    text-decoration: underline solid transparent;
-    transition: text-decoration 0.5s ease;
-    &:hover {
-      text-decoration: underline solid var(--color-gray-400);
-    }
-  }
-}
-
-.header:hover {
-  .logo {
-    animation: wiggle 0.2s 1;
-  }
-  #eyes_2 {
-    visibility: visible;
-  }
-  #eyes_1 {
-    visibility: hidden;
-  }
-
-  nav {
-    display: flex;
-    pointer-events: all;
-    display: flex;
-    animation: fadeIn 0.5s ease;
-  }
-
-  .logo-button {
-    border-color: var(--color-gray-200);
-    box-shadow: 0px 100px 28px 0px rgba(0, 0, 0, 0),
-      0px 64px 26px 0px rgba(0, 0, 0, 0.01),
-      0px 36px 22px 0px rgba(0, 0, 0, 0.03),
-      0px 16px 16px 0px rgba(0, 0, 0, 0.04), 0px 4px 9px 0px rgba(0, 0, 0, 0.05);
-  }
-}
-
-@keyframes fadeIn {
-  from {
-    opacity: 0;
-  }
-  to {
-    opacity: 1;
-  }
-}
-
-@keyframes wiggle {
-  0% {
-    transform: translateX(0);
-  }
-  25% {
-    transform: translateX(-5px);
-  }
-  50% {
-    transform: translateX(5px);
-  }
-  75% {
-    transform: translateX(-5px);
-  }
-  100% {
-    transform: translateX(0);
-  }
-}
-
-.button {
-  border-radius: var(--borderRadius-md);
-  border: 1px solid transparent;
-  padding: 0 1.5rem;
-  height: var(--input-height);
-  font-size: 1rem;
-  font-weight: 600;
-  font-family: inherit;
-  background-color: var(--color-gray-950);
-  color: white;
-  cursor: pointer;
-  display: flex;
-  flex-direction: row;
-  gap: 0.5rem;
-  align-items: center;
-}
-.button > svg {
-  width: 20px;
-  height: 20px;
-}
-.button:hover:not(:disabled) {
-  background-color: var(--color-gray-600);
-}
-.button:disabled {
-  cursor: not-allowed;
-  background-color: var(--color-gray-300);
-  color: var(--color-gray-100);
-}
-
-.button-ghost {
-  border: 1px solid var(--color-gray-300);
-  background-color: white;
-  color: var(--color-gray-950);
-}
-.button-ghost:hover:not(:disabled) {
-  background-color: white;
-  border-color: var(--color-gray-600);
-}
-
-.button-icon {
-  padding: 1rem;
-}
-
-.alert {
-  border: 1px solid black;
-  border-radius: var(--borderRadius-md);
-  padding: 1rem;
-  display: flex;
-  flex-flow: column wrap;
-  gap: 2;
-  font-size: 0.875rem;
-
-  span {
-    font-size: 1rem;
-    font-weight: bold;
-  }
-}
-
-.alert-danger {
-  border-color: red;
-  color: red;
-}
-
-@keyframes spin {
-  0% {
-    transform: rotate(0deg);
-  }
-  100% {
-    transform: rotate(360deg);
-  }
-}
-
-.animate-spin {
-  animation: spin 1s linear infinite;
-}
-
-.controls {
-}
-
-.card {
-  padding: 12px;
-  border-radius: var(--borderRadius-lg);
-  background: #fff;
-  box-shadow: 0px 360px 101px 0px rgba(0, 0, 0, 0),
-    0px 231px 92px 0px rgba(0, 0, 0, 0), 0px 130px 78px 0px rgba(0, 0, 0, 0.02),
-    0px 58px 58px 0px rgba(0, 0, 0, 0.03), 0px 14px 32px 0px rgba(0, 0, 0, 0.03);
-
-  background-image: linear-gradient(90deg, white, white),
-    linear-gradient(0deg, var(--color-gray-300), var(--color-gray-200));
-  background-clip: padding-box, border-box;
-  background-origin: border-box;
-  border: 1px solid transparent;
-}
-
-.card-appear {
-  animation: appear 0.5s ease-out forwards;
-}
-
-.card-inner {
-  padding: 20px;
-  max-width: 420px;
-  display: flex;
-  gap: 24px;
-  flex-direction: column;
-  justify-content: center;
-  place-items: center;
-}
-
-.card-header {
-  font-size: 1.5rem;
-  font-weight: 600;
-  margin: 0px;
-}
-
-.card-text {
-  font-size: 1.125rem;
-  color: var(--color-gray-500);
-  text-wrap: pretty;
-  margin: 0px;
-}
-
-@keyframes appear {
-  from {
-    opacity: 0;
-    transform: translateY(1rem);
-  }
-  to {
-    opacity: 1;
-    transform: translateY(0);
-  }
-}
-
-select {
-  appearance: none;
-  background-image: url("data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQgNkw4IDEwTDEyIDYiIHN0cm9rZT0iIzY0NzQ4QiIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+Cjwvc3ZnPgo=");
-  background-repeat: no-repeat;
-  background-position: right 1rem top 50%;
-  background-size: 16px auto;
-  border-radius: var(--borderRadius-md);
-  border: 1px solid var(--color-gray-300);
-  padding: 0 1rem;
-  height: var(--input-height);
-  font-size: var(--font-size-sm);
-  white-space: nowrap;
-  text-overflow: ellipsis;
-  padding-right: 3rem;
-}
-
-dialog {
-  max-width: 420px;
-  padding: 2rem;
-  border-radius: var(--borderRadius-lg);
-  background: #fff;
-  box-shadow: 0px 360px 101px 0px rgba(0, 0, 0, 0),
-    0px 231px 92px 0px rgba(0, 0, 0, 0), 0px 130px 78px 0px rgba(0, 0, 0, 0.02),
-    0px 58px 58px 0px rgba(0, 0, 0, 0.03), 0px 14px 32px 0px rgba(0, 0, 0, 0.03);
-
-  background-image: linear-gradient(90deg, white, white),
-    linear-gradient(0deg, var(--color-gray-300), var(--color-gray-200));
-  background-clip: padding-box, border-box;
-  background-origin: border-box;
-  border: 1px solid transparent;
-  animation: appear 0.5s ease-out forwards;
-
-  > h2 {
-    font-size: var(--font-size-xl);
-    margin: 0;
-    margin-bottom: 2rem;
-  }
-
-  > button {
-    margin: 2rem auto 0 auto;
-  }
-}
-
-dialog::backdrop {
-  background-color: rgba(255, 255, 255, 0.5);
-  backdrop-filter: blur(5px);
-}

examples/web-ui/src/main.tsx

@@ -1,18 +0,0 @@
-import React from "react";
-import ReactDOM from "react-dom/client";
-import App from "./App.tsx";
-import Header from "./components/header.tsx";
-import { DailyProvider } from "@daily-co/daily-react";
-
-import "./global.css";
-
-ReactDOM.createRoot(document.getElementById("root")!).render(
-  <React.StrictMode>
-    <Header />
-    <main>
-      <DailyProvider>
-        <App />
-      </DailyProvider>
-    </main>
-  </React.StrictMode>
-);

examples/web-ui/src/vite-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="vite/client" />

examples/web-ui/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "useDefineForClassFields": true,
-    "lib": ["ES2020", "DOM", "DOM.Iterable"],
-    "module": "ESNext",
-    "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "noEmit": true,
-    "jsx": "react-jsx",
-
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "noFallthroughCasesInSwitch": true
-  },
-  "include": ["src"],
-  "references": [{ "path": "./tsconfig.node.json" }]
-}

examples/web-ui/tsconfig.node.json

@@ -1,11 +0,0 @@
-{
-  "compilerOptions": {
-    "composite": true,
-    "skipLibCheck": true,
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "allowSyntheticDefaultImports": true,
-    "strict": true
-  },
-  "include": ["vite.config.ts"]
-}

examples/web-ui/vite.config.ts

@@ -1,7 +0,0 @@
-import { defineConfig } from "vite";
-import react from "@vitejs/plugin-react";
-import webfontDownload from "vite-plugin-webfont-dl";
-
-export default defineConfig({
-  plugins: [react(), webfontDownload()],
-});

linux-py3.10-requirements.txt

@@ -5,14 +5,14 @@
 #    pip-compile --all-extras pyproject.toml
 #
 aiohttp==3.9.5
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 aiosignal==1.3.1
     # via aiohttp
-annotated-types==0.6.0
+annotated-types==0.7.0
     # via pydantic
-anthropic==0.25.8
-    # via pipecat (pyproject.toml)
-anyio==4.3.0
+anthropic==0.25.9
+    # via pipecat-ai (pyproject.toml)
+anyio==4.4.0
     # via
     #   anthropic
     #   httpx
@@ -24,9 +24,11 @@ attrs==23.2.0
 av==12.0.0
     # via faster-whisper
 azure-cognitiveservices-speech==1.37.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 blinker==1.8.2
     # via flask
+cachetools==5.3.3
+    # via google-auth
 certifi==2024.2.2
     # via
     #   httpcore
@@ -40,20 +42,20 @@ coloredlogs==15.0.1
     # via onnxruntime
 ctranslate2==4.2.1
     # via faster-whisper
-daily-python==0.7.4
-    # via pipecat (pyproject.toml)
+daily-python==0.9.0
+    # via pipecat-ai (pyproject.toml)
 distro==1.9.0
     # via
     #   anthropic
     #   openai
 einops==0.8.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 exceptiongroup==1.2.1
     # via anyio
 fal-client==0.4.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 faster-whisper==1.0.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 filelock==3.14.0
     # via
     #   huggingface-hub
@@ -64,25 +66,60 @@ filelock==3.14.0
 flask==3.0.3
     # via
     #   flask-cors
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
 flask-cors==4.0.1
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 flatbuffers==24.3.25
     # via onnxruntime
 frozenlist==1.4.1
     # via
     #   aiohttp
     #   aiosignal
-fsspec==2024.3.1
+fsspec==2024.5.0
     # via
     #   huggingface-hub
     #   torch
-grpcio==1.63.0
-    # via pyht
+future==1.0.0
+    # via pyloudnorm
+google-ai-generativelanguage==0.6.4
+    # via google-generativeai
+google-api-core[grpc]==2.19.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-python-client
+    #   google-generativeai
+google-api-python-client==2.131.0
+    # via google-generativeai
+google-auth==2.29.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+    #   google-api-python-client
+    #   google-auth-httplib2
+    #   google-generativeai
+google-auth-httplib2==0.2.0
+    # via google-api-python-client
+google-generativeai==0.5.4
+    # via pipecat-ai (pyproject.toml)
+googleapis-common-protos==1.63.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+grpcio==1.64.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+    #   pyht
+grpcio-status==1.62.2
+    # via google-api-core
 h11==0.14.0
     # via httpcore
 httpcore==1.0.5
     # via httpx
+httplib2==0.22.0
+    # via
+    #   google-api-python-client
+    #   google-auth-httplib2
 httpx==0.27.0
     # via
     #   anthropic
@@ -90,7 +127,7 @@ httpx==0.27.0
     #   openai
 httpx-sse==0.4.0
     # via fal-client
-huggingface-hub==0.23.0
+huggingface-hub==0.23.2
     # via
     #   faster-whisper
     #   timm
@@ -111,7 +148,7 @@ jinja2==3.1.4
     #   flask
     #   torch
 loguru==0.7.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 markupsafe==2.1.5
     # via
     #   jinja2
@@ -128,7 +165,9 @@ numpy==1.26.4
     # via
     #   ctranslate2
     #   onnxruntime
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
+    #   pyloudnorm
+    #   scipy
     #   torchvision
     #   transformers
 nvidia-cublas-cu12==12.1.3.1
@@ -156,16 +195,16 @@ nvidia-cusparse-cu12==12.1.0.106
     #   torch
 nvidia-nccl-cu12==2.20.5
     # via torch
-nvidia-nvjitlink-cu12==12.4.127
+nvidia-nvjitlink-cu12==12.5.40
     # via
     #   nvidia-cusolver-cu12
     #   nvidia-cusparse-cu12
 nvidia-nvtx-cu12==12.1.105
     # via torch
-onnxruntime==1.17.3
+onnxruntime==1.18.0
     # via faster-whisper
 openai==1.26.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 packaging==24.0
     # via
     #   huggingface-hub
@@ -173,41 +212,67 @@ packaging==24.0
     #   transformers
 pillow==10.3.0
     # via
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   torchvision
+proto-plus==1.23.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
 protobuf==4.25.3
     # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+    #   google-generativeai
+    #   googleapis-common-protos
+    #   grpcio-status
     #   onnxruntime
+    #   proto-plus
     #   pyht
+pyasn1==0.6.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.4.0
+    # via google-auth
 pyaudio==0.2.14
-    # via pipecat (pyproject.toml)
-pydantic==2.7.1
+    # via pipecat-ai (pyproject.toml)
+pydantic==2.7.2
     # via
     #   anthropic
+    #   google-generativeai
     #   openai
-pydantic-core==2.18.2
+pydantic-core==2.18.3
     # via pydantic
 pyht==0.0.28
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
+pyloudnorm==0.1.1
+    # via pipecat-ai (pyproject.toml)
+pyparsing==3.1.2
+    # via httplib2
 python-dotenv==1.0.1
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 pyyaml==6.0.1
     # via
     #   ctranslate2
     #   huggingface-hub
     #   timm
     #   transformers
-regex==2024.5.10
+regex==2024.5.15
     # via transformers
-requests==2.31.0
+requests==2.32.2
     # via
+    #   google-api-core
     #   huggingface-hub
     #   pyht
     #   transformers
+rsa==4.9
+    # via google-auth
 safetensors==0.4.3
     # via
     #   timm
     #   transformers
+scipy==1.13.1
+    # via pyloudnorm
 sniffio==1.3.1
     # via
     #   anthropic
@@ -219,7 +284,7 @@ sympy==1.12
     #   onnxruntime
     #   torch
 timm==0.9.16
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 tokenizers==0.19.1
     # via
     #   anthropic
@@ -227,37 +292,41 @@ tokenizers==0.19.1
     #   transformers
 torch==2.3.0
     # via
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   timm
     #   torchaudio
     #   torchvision
 torchaudio==2.3.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 torchvision==0.18.0
     # via timm
 tqdm==4.66.4
     # via
+    #   google-generativeai
     #   huggingface-hub
     #   openai
     #   transformers
 transformers==4.40.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 triton==2.3.0
     # via torch
 typing-extensions==4.11.0
     # via
     #   anthropic
     #   anyio
+    #   google-generativeai
     #   huggingface-hub
     #   openai
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   pydantic
     #   pydantic-core
     #   torch
+uritemplate==4.1.1
+    # via google-api-python-client
 urllib3==2.2.1
     # via requests
 websockets==12.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 werkzeug==3.0.3
     # via flask
 yarl==1.9.4

macos-py3.10-requirements.txt

@@ -5,14 +5,16 @@
 #    pip-compile --all-extras pyproject.toml
 #
 aiohttp==3.9.5
-    # via pipecat (pyproject.toml)
+    # via
+    #   cartesia
+    #   pipecat-ai (pyproject.toml)
 aiosignal==1.3.1
     # via aiohttp
-annotated-types==0.6.0
+annotated-types==0.7.0
     # via pydantic
-anthropic==0.25.8
-    # via pipecat (pyproject.toml)
-anyio==4.3.0
+anthropic==0.25.9
+    # via pipecat-ai (pyproject.toml)
+anyio==4.4.0
     # via
     #   anthropic
     #   httpx
@@ -21,17 +23,23 @@ async-timeout==4.0.3
     # via aiohttp
 attrs==23.2.0
     # via aiohttp
-av==12.0.0
+av==12.1.0
     # via faster-whisper
 azure-cognitiveservices-speech==1.37.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 blinker==1.8.2
     # via flask
+cachetools==5.3.3
+    # via google-auth
+cartesia==0.1.0
+    # via pipecat-ai (pyproject.toml)
 certifi==2024.2.2
     # via
     #   httpcore
     #   httpx
     #   requests
+cffi==1.16.0
+    # via sounddevice
 charset-normalizer==3.3.2
     # via requests
 click==8.1.7
@@ -40,20 +48,22 @@ coloredlogs==15.0.1
     # via onnxruntime
 ctranslate2==4.2.1
     # via faster-whisper
-daily-python==0.7.4
-    # via pipecat (pyproject.toml)
+daily-python==0.9.1
+    # via pipecat-ai (pyproject.toml)
 distro==1.9.0
     # via
     #   anthropic
     #   openai
 einops==0.8.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 exceptiongroup==1.2.1
-    # via anyio
+    # via
+    #   anyio
+    #   pytest
 fal-client==0.4.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 faster-whisper==1.0.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 filelock==3.14.0
     # via
     #   huggingface-hub
@@ -63,33 +73,69 @@ filelock==3.14.0
 flask==3.0.3
     # via
     #   flask-cors
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
 flask-cors==4.0.1
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 flatbuffers==24.3.25
     # via onnxruntime
 frozenlist==1.4.1
     # via
     #   aiohttp
     #   aiosignal
-fsspec==2024.3.1
+fsspec==2024.5.0
     # via
     #   huggingface-hub
     #   torch
-grpcio==1.63.0
-    # via pyht
+future==1.0.0
+    # via pyloudnorm
+google-ai-generativelanguage==0.6.4
+    # via google-generativeai
+google-api-core[grpc]==2.19.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-python-client
+    #   google-generativeai
+google-api-python-client==2.131.0
+    # via google-generativeai
+google-auth==2.29.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+    #   google-api-python-client
+    #   google-auth-httplib2
+    #   google-generativeai
+google-auth-httplib2==0.2.0
+    # via google-api-python-client
+google-generativeai==0.5.4
+    # via pipecat-ai (pyproject.toml)
+googleapis-common-protos==1.63.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+grpcio==1.64.0
+    # via
+    #   google-api-core
+    #   grpcio-status
+    #   pyht
+grpcio-status==1.62.2
+    # via google-api-core
 h11==0.14.0
     # via httpcore
 httpcore==1.0.5
     # via httpx
+httplib2==0.22.0
+    # via
+    #   google-api-python-client
+    #   google-auth-httplib2
 httpx==0.27.0
     # via
     #   anthropic
+    #   cartesia
     #   fal-client
     #   openai
 httpx-sse==0.4.0
     # via fal-client
-huggingface-hub==0.23.0
+huggingface-hub==0.23.2
     # via
     #   faster-whisper
     #   timm
@@ -103,6 +149,8 @@ idna==3.7
     #   httpx
     #   requests
     #   yarl
+iniconfig==2.0.0
+    # via pytest
 itsdangerous==2.2.0
     # via flask
 jinja2==3.1.4
@@ -110,7 +158,7 @@ jinja2==3.1.4
     #   flask
     #   torch
 loguru==0.7.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 markupsafe==2.1.5
     # via
     #   jinja2
@@ -127,103 +175,151 @@ numpy==1.26.4
     # via
     #   ctranslate2
     #   onnxruntime
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
+    #   pyloudnorm
+    #   scipy
     #   torchvision
     #   transformers
-onnxruntime==1.17.3
+onnxruntime==1.18.0
     # via faster-whisper
 openai==1.26.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 packaging==24.0
     # via
     #   huggingface-hub
     #   onnxruntime
+    #   pytest
     #   transformers
 pillow==10.3.0
     # via
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   torchvision
+pluggy==1.5.0
+    # via pytest
+proto-plus==1.23.0
+    # via
+    #   google-ai-generativelanguage
+    #   google-api-core
 protobuf==4.25.3
     # via
+    #   google-ai-generativelanguage
+    #   google-api-core
+    #   google-generativeai
+    #   googleapis-common-protos
+    #   grpcio-status
     #   onnxruntime
+    #   proto-plus
     #   pyht
+pyasn1==0.6.0
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.4.0
+    # via google-auth
 pyaudio==0.2.14
-    # via pipecat (pyproject.toml)
-pydantic==2.7.1
+    # via pipecat-ai (pyproject.toml)
+pycparser==2.22
+    # via cffi
+pydantic==2.7.2
     # via
     #   anthropic
+    #   google-generativeai
     #   openai
-pydantic-core==2.18.2
+pydantic-core==2.18.3
     # via pydantic
 pyht==0.0.28
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
+pyloudnorm==0.1.1
+    # via pipecat-ai (pyproject.toml)
+pyparsing==3.1.2
+    # via httplib2
+pytest==8.2.1
+    # via pytest-asyncio
+pytest-asyncio==0.23.7
+    # via cartesia
 python-dotenv==1.0.1
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 pyyaml==6.0.1
     # via
     #   ctranslate2
     #   huggingface-hub
     #   timm
     #   transformers
-regex==2024.5.10
+regex==2024.5.15
     # via transformers
-requests==2.31.0
+requests==2.32.3
     # via
+    #   cartesia
+    #   google-api-core
     #   huggingface-hub
     #   pyht
     #   transformers
+rsa==4.9
+    # via google-auth
 safetensors==0.4.3
     # via
     #   timm
     #   transformers
+scipy==1.13.1
+    # via pyloudnorm
 sniffio==1.3.1
     # via
     #   anthropic
     #   anyio
     #   httpx
     #   openai
-sympy==1.12
+sounddevice==0.4.7
+    # via pipecat-ai (pyproject.toml)
+sympy==1.12.1
     # via
     #   onnxruntime
     #   torch
 timm==0.9.16
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 tokenizers==0.19.1
     # via
     #   anthropic
     #   faster-whisper
     #   transformers
+tomli==2.0.1
+    # via pytest
 torch==2.3.0
     # via
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   timm
     #   torchaudio
     #   torchvision
 torchaudio==2.3.0
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 torchvision==0.18.0
     # via timm
 tqdm==4.66.4
     # via
+    #   google-generativeai
     #   huggingface-hub
     #   openai
     #   transformers
 transformers==4.40.2
-    # via pipecat (pyproject.toml)
+    # via pipecat-ai (pyproject.toml)
 typing-extensions==4.11.0
     # via
     #   anthropic
     #   anyio
+    #   google-generativeai
     #   huggingface-hub
     #   openai
-    #   pipecat (pyproject.toml)
+    #   pipecat-ai (pyproject.toml)
     #   pydantic
     #   pydantic-core
     #   torch
+uritemplate==4.1.1
+    # via google-api-python-client
 urllib3==2.2.1
     # via requests
 websockets==12.0
-    # via pipecat (pyproject.toml)
+    # via
+    #   cartesia
+    #   pipecat-ai (pyproject.toml)
 werkzeug==3.0.3
     # via flask
 yarl==1.9.4

pyproject.toml

@@ -24,6 +24,7 @@ dependencies = [
     "numpy~=1.26.4",
     "loguru~=0.7.0",
     "Pillow~=10.3.0",
+    "pyloudnorm~=0.1.1",
     "typing-extensions~=4.11.0",
 ]
 
@@ -34,9 +35,11 @@ Website = "https://pipecat.ai"
 [project.optional-dependencies]
 anthropic = [ "anthropic~=0.25.7" ]
 azure = [ "azure-cognitiveservices-speech~=1.37.0" ]
-daily = [ "daily-python~=0.7.4" ]
+cartesia = [ "numpy~=1.26.0", "sounddevice", "cartesia" ]
+daily = [ "daily-python~=0.9.0" ]
 examples = [ "python-dotenv~=1.0.0", "flask~=3.0.3", "flask_cors~=4.0.1" ]
 fal = [ "fal-client~=0.4.0" ]
+google = [ "google-generativeai~=0.5.3" ]
 fireworks = [ "openai~=1.26.0" ]
 local = [ "pyaudio~=0.2.0" ]
 moondream = [ "einops~=0.8.0", "timm~=0.9.16", "transformers~=4.40.2" ]

src/pipecat/frames/frames.py

@@ -119,7 +119,7 @@ class TextFrame(DataFrame):
     text: str
 
     def __str__(self):
-        return f'{self.name}: "{self.text}"'
+        return f"{self.name}(text: {self.text})"
 
 
 @dataclass
@@ -132,7 +132,7 @@ class TranscriptionFrame(TextFrame):
     timestamp: str
 
     def __str__(self):
-        return f"{self.name}(user: {self.user_id}, timestamp: {self.timestamp})"
+        return f"{self.name}(user: {self.user_id}, text: {self.text}, timestamp: {self.timestamp})"
 
 
 @dataclass
@@ -143,7 +143,7 @@ class InterimTranscriptionFrame(TextFrame):
     timestamp: str
 
     def __str__(self):
-        return f"{self.name}(user: {self.user_id}, timestamp: {self.timestamp})"
+        return f"{self.name}(user: {self.user_id}, text: {self.text}, timestamp: {self.timestamp})"
 
 
 @dataclass
@@ -187,7 +187,7 @@ class SystemFrame(Frame):
 @dataclass
 class StartFrame(SystemFrame):
     """This is the first frame that should be pushed down a pipeline."""
-    pass
+    allow_interruptions: bool = False
 
 
 @dataclass
@@ -216,6 +216,28 @@ class StopTaskFrame(SystemFrame):
     pass
 
 
+@dataclass
+class StartInterruptionFrame(SystemFrame):
+    """Emitted by VAD to indicate that a user has started speaking (i.e. is
+    interruption). This is similar to UserStartedSpeakingFrame except that it
+    should be pushed concurrently with other frames (so the order is not
+    guaranteed).
+
+    """
+    pass
+
+
+@dataclass
+class StopInterruptionFrame(SystemFrame):
+    """Emitted by VAD to indicate that a user has stopped speaking (i.e. no more
+    interruptions). This is similar to UserStoppedSpeakingFrame except that it
+    should be pushed concurrently with other frames (so the order is not
+    guaranteed).
+
+    """
+    pass
+
+
 #
 # Control frames
 #
@@ -238,6 +260,20 @@ class EndFrame(ControlFrame):
     pass
 
 
+@dataclass
+class LLMFullResponseStartFrame(ControlFrame):
+    """Used to indicate the beginning of a full LLM response. Following
+    LLMResponseStartFrame, TextFrame and LLMResponseEndFrame for each sentence
+    until a LLMFullResponseEndFrame."""
+    pass
+
+
+@dataclass
+class LLMFullResponseEndFrame(ControlFrame):
+    """Indicates the end of a full LLM response."""
+    pass
+
+
 @dataclass
 class LLMResponseStartFrame(ControlFrame):
     """Used to indicate the beginning of an LLM response. Following TextFrames
@@ -271,7 +307,7 @@ class UserStoppedSpeakingFrame(ControlFrame):
 @dataclass
 class TTSStartedFrame(ControlFrame):
     """Used to indicate the beginning of a TTS response. Following
-    AudioRawFrames are part of the TTS response until an TTSEndFrame. These
+    AudioRawFrames are part of the TTS response until an TTSStoppedFrame. These
     frames can be used for aggregating audio frames in a transport to optimize
     the size of frames sent to the session, without needing to control this in
     the TTS service.

src/pipecat/pipeline/merge_pipeline.py

@@ -1,5 +1,5 @@
 from typing import List
-from pipecat.pipeline.frames import EndFrame, EndPipeFrame
+from pipecat.frames.frames import EndFrame
 from pipecat.pipeline.pipeline import Pipeline
 
 
@@ -16,8 +16,7 @@ class SequentialMergePipeline(Pipeline):
             while True:
                 frame = await pipeline.sink.get()
                 if isinstance(
-                        frame, EndFrame) or isinstance(
-                        frame, EndPipeFrame):
+                        frame, EndFrame):
                     break
                 await self.sink.put(frame)
 

src/pipecat/pipeline/parallel_pipeline.py

@@ -63,7 +63,7 @@ class ParallelPipeline(FrameProcessor):
             if not isinstance(processors, list):
                 raise TypeError(f"ParallelPipeline argument {processors} is not a list")
 
-            # We add a source at before the pipeline and a sink after.
+            # We will add a source before the pipeline and a sink after.
             source = Source(self._up_queue)
             sink = Sink(self._down_queue)
             self._sources.append(source)

src/pipecat/pipeline/task.py

@@ -8,6 +8,8 @@ import asyncio
 
 from typing import AsyncIterable, Iterable
 
+from pydantic import BaseModel
+
 from pipecat.frames.frames import CancelFrame, EndFrame, ErrorFrame, Frame, StartFrame, StopTaskFrame
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.utils.utils import obj_count, obj_id
@@ -15,6 +17,10 @@ from pipecat.utils.utils import obj_count, obj_id
 from loguru import logger
 
 
+class PipelineParams(BaseModel):
+    allow_interruptions: bool = False
+
+
 class Source(FrameProcessor):
 
     def __init__(self, up_queue: asyncio.Queue):
@@ -31,13 +37,14 @@ class Source(FrameProcessor):
 
 class PipelineTask:
 
-    def __init__(self, pipeline: FrameProcessor):
+    def __init__(self, pipeline: FrameProcessor, params: PipelineParams = PipelineParams()):
         self.id: int = obj_id()
         self.name: str = f"{self.__class__.__name__}#{obj_count(self)}"
 
         self._pipeline = pipeline
+        self._params = params
 
-        self._task_queue = asyncio.Queue()
+        self._down_queue = asyncio.Queue()
         self._up_queue = asyncio.Queue()
 
         self._source = Source(self._up_queue)
@@ -49,15 +56,20 @@ class PipelineTask:
 
     async def cancel(self):
         logger.debug(f"Canceling pipeline task {self}")
-        await self.queue_frame(CancelFrame())
+        # Make sure everything is cleaned up downstream. This is sent
+        # out-of-band from the main streaming task which is what we want since
+        # we want to cancel right away.
+        await self._source.process_frame(CancelFrame(), FrameDirection.DOWNSTREAM)
+        self._process_down_task.cancel()
+        self._process_up_task.cancel()
 
     async def run(self):
-        await asyncio.gather(self._process_task_queue(), self._process_up_queue())
-        await self._source.cleanup()
-        await self._pipeline.cleanup()
+        self._process_up_task = asyncio.create_task(self._process_up_queue())
+        self._process_down_task = asyncio.create_task(self._process_down_queue())
+        await asyncio.gather(self._process_up_task, self._process_down_task)
 
     async def queue_frame(self, frame: Frame):
-        await self._task_queue.put(frame)
+        await self._down_queue.put(frame)
 
     async def queue_frames(self, frames: Iterable[Frame] | AsyncIterable[Frame]):
         if isinstance(frames, AsyncIterable):
@@ -69,29 +81,37 @@ class PipelineTask:
         else:
             raise Exception("Frames must be an iterable or async iterable")
 
-    async def _process_task_queue(self):
-        await self._source.process_frame(StartFrame(), FrameDirection.DOWNSTREAM)
+    async def _process_down_queue(self):
+        await self._source.process_frame(
+            StartFrame(allow_interruptions=self._params.allow_interruptions), FrameDirection.DOWNSTREAM)
         running = True
+        should_cleanup = True
         while running:
-            frame = await self._task_queue.get()
-            await self._source.process_frame(frame, FrameDirection.DOWNSTREAM)
-            self._task_queue.task_done()
-            running = not (isinstance(frame, StopTaskFrame) or
-                           isinstance(frame, CancelFrame) or
-                           isinstance(frame, EndFrame))
-        # We just enqueue None to terminate the task.
-        await self._up_queue.put(None)
+            try:
+                frame = await self._down_queue.get()
+                await self._source.process_frame(frame, FrameDirection.DOWNSTREAM)
+                running = not (isinstance(frame, StopTaskFrame) or isinstance(frame, EndFrame))
+                should_cleanup = not isinstance(frame, StopTaskFrame)
+                self._down_queue.task_done()
+            except asyncio.CancelledError:
+                break
+        # Cleanup only if we need to.
+        if should_cleanup:
+            await self._source.cleanup()
+            await self._pipeline.cleanup()
+        # We just enqueue None to terminate the task gracefully.
+        self._process_up_task.cancel()
 
     async def _process_up_queue(self):
-        running = True
-        while running:
-            frame = await self._up_queue.get()
-            if frame:
+        while True:
+            try:
+                frame = await self._up_queue.get()
                 if isinstance(frame, ErrorFrame):
                     logger.error(f"Error running app: {frame.error}")
                     await self.queue_frame(CancelFrame())
-            self._up_queue.task_done()
-            running = frame is not None
+                self._up_queue.task_done()
+            except asyncio.CancelledError:
+                break
 
     def __str__(self):
         return self.name

src/pipecat/processors/aggregators/gated.py

@@ -17,7 +17,7 @@ class GatedAggregator(FrameProcessor):
     Yields gate-opening frame before any accumulated frames, then ensuing frames
     until and not including the gate-closed frame.
 
-    >>> from pipecat.pipeline.frames import ImageFrame
+    >>> from pipecat.frames.frames import ImageFrame
 
     >>> async def print_frames(aggregator, frame):
     ...     async for frame in aggregator.process_frame(frame):

src/pipecat/processors/aggregators/llm_context.py

@@ -1,82 +0,0 @@
-#
-# Copyright (c) 2024, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-from pipecat.frames.frames import Frame, InterimTranscriptionFrame, LLMMessagesFrame, TextFrame
-from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
-
-
-class LLMContextAggregator(FrameProcessor):
-    def __init__(
-        self,
-        messages: list[dict],
-        role: str,
-        complete_sentences=True,
-        pass_through=True,
-    ):
-        super().__init__()
-        self._messages = messages
-        self._role = role
-        self._sentence = ""
-        self._complete_sentences = complete_sentences
-        self._pass_through = pass_through
-
-    async def process_frame(self, frame: Frame, direction: FrameDirection):
-        # We don't do anything with non-text frames, pass it along to next in
-        # the pipeline.
-        if not isinstance(frame, TextFrame):
-            await self.push_frame(frame, direction)
-            return
-
-        # If we get interim results, we ignore them.
-        if isinstance(frame, InterimTranscriptionFrame):
-            return
-
-        # The common case for "pass through" is receiving frames from the LLM that we'll
-        # use to update the "assistant" LLM messages, but also passing the text frames
-        # along to a TTS service to be spoken to the user.
-        if self._pass_through:
-            await self.push_frame(frame, direction)
-
-        # TODO: split up transcription by participant
-        if self._complete_sentences:
-            # type: ignore -- the linter thinks this isn't a TextFrame, even
-            # though we check it above
-            self._sentence += frame.text
-            if self._sentence.endswith((".", "?", "!")):
-                self._messages.append(
-                    {"role": self._role, "content": self._sentence})
-                self._sentence = ""
-                await self.push_frame(LLMMessagesFrame(self._messages))
-        else:
-            # type: ignore -- the linter thinks this isn't a TextFrame, even
-            # though we check it above
-            self._messages.append({"role": self._role, "content": frame.text})
-            await self.push_frame(LLMMessagesFrame(self._messages))
-
-
-class LLMUserContextAggregator(LLMContextAggregator):
-    def __init__(
-            self,
-            messages: list[dict],
-            complete_sentences=True):
-        super().__init__(
-            messages,
-            "user",
-            complete_sentences,
-            pass_through=False)
-
-
-class LLMAssistantContextAggregator(LLMContextAggregator):
-    def __init__(
-            self,
-            messages: list[dict],
-            complete_sentences=True):
-        super().__init__(
-            messages,
-            "assistant",
-            complete_sentences,
-            pass_through=True,
-        )

src/pipecat/processors/aggregators/llm_response.py

@@ -6,15 +6,20 @@
 
 from typing import List
 
+from pipecat.services.openai import OpenAILLMContextFrame, OpenAILLMContext
+
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.frames.frames import (
     Frame,
     InterimTranscriptionFrame,
-    LLMMessagesFrame,
-    LLMResponseStartFrame,
-    TextFrame,
+    LLMFullResponseEndFrame,
+    LLMFullResponseStartFrame,
     LLMResponseEndFrame,
+    LLMResponseStartFrame,
+    LLMMessagesFrame,
+    StartInterruptionFrame,
     TranscriptionFrame,
+    TextFrame,
     UserStartedSpeakingFrame,
     UserStoppedSpeakingFrame)
 
@@ -29,7 +34,8 @@ class LLMResponseAggregator(FrameProcessor):
         start_frame,
         end_frame,
         accumulator_frame: TextFrame,
-        interim_accumulator_frame: TextFrame | None = None
+        interim_accumulator_frame: TextFrame | None = None,
+        handle_interruptions: bool = False
     ):
         super().__init__()
 
@@ -39,12 +45,18 @@ class LLMResponseAggregator(FrameProcessor):
         self._end_frame = end_frame
         self._accumulator_frame = accumulator_frame
         self._interim_accumulator_frame = interim_accumulator_frame
-        self._seen_start_frame = False
-        self._seen_end_frame = False
-        self._seen_interim_results = False
+        self._handle_interruptions = handle_interruptions
 
-        self._aggregation = ""
-        self._aggregating = False
+        # Reset our accumulator state.
+        self._reset()
+
+    @property
+    def messages(self):
+        return self._messages
+
+    @property
+    def role(self):
+        return self._role
 
     #
     # Frame processor
@@ -70,10 +82,14 @@ class LLMResponseAggregator(FrameProcessor):
         send_aggregation = False
 
         if isinstance(frame, self._start_frame):
-            self._seen_start_frame = True
+            self._aggregation = ""
             self._aggregating = True
+            self._seen_start_frame = True
+            self._seen_end_frame = False
+            self._seen_interim_results = False
         elif isinstance(frame, self._end_frame):
             self._seen_end_frame = True
+            self._seen_start_frame = False
 
             # We might have received the end frame but we might still be
             # aggregating (i.e. we have seen interim results but not the final
@@ -95,6 +111,11 @@ class LLMResponseAggregator(FrameProcessor):
             self._seen_interim_results = False
         elif self._interim_accumulator_frame and isinstance(frame, self._interim_accumulator_frame):
             self._seen_interim_results = True
+        elif self._handle_interruptions and isinstance(frame, StartInterruptionFrame):
+            await self._push_aggregation()
+            # Reset anyways
+            self._reset()
+            await self.push_frame(frame, direction)
         else:
             await self.push_frame(frame, direction)
 
@@ -104,14 +125,20 @@ class LLMResponseAggregator(FrameProcessor):
     async def _push_aggregation(self):
         if len(self._aggregation) > 0:
             self._messages.append({"role": self._role, "content": self._aggregation})
+
+            # Reset the aggregation. Reset it before pushing it down, otherwise
+            # if the tasks gets cancelled we won't be able to clear things up.
+            self._aggregation = ""
+
             frame = LLMMessagesFrame(self._messages)
             await self.push_frame(frame)
 
-            # Reset
-            self._aggregation = ""
-            self._seen_start_frame = False
-            self._seen_end_frame = False
-            self._seen_interim_results = False
+    def _reset(self):
+        self._aggregation = ""
+        self._aggregating = False
+        self._seen_start_frame = False
+        self._seen_end_frame = False
+        self._seen_interim_results = False
 
 
 class LLMAssistantResponseAggregator(LLMResponseAggregator):
@@ -119,9 +146,10 @@ class LLMAssistantResponseAggregator(LLMResponseAggregator):
         super().__init__(
             messages=messages,
             role="assistant",
-            start_frame=LLMResponseStartFrame,
-            end_frame=LLMResponseEndFrame,
-            accumulator_frame=TextFrame
+            start_frame=LLMFullResponseStartFrame,
+            end_frame=LLMFullResponseEndFrame,
+            accumulator_frame=TextFrame,
+            handle_interruptions=True
         )
 
 
@@ -181,9 +209,50 @@ class LLMFullResponseAggregator(FrameProcessor):
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         if isinstance(frame, TextFrame):
             self._aggregation += frame.text
-        elif isinstance(frame, LLMResponseEndFrame):
+        elif isinstance(frame, LLMFullResponseEndFrame):
             await self.push_frame(TextFrame(self._aggregation))
             await self.push_frame(frame)
             self._aggregation = ""
         else:
             await self.push_frame(frame, direction)
+
+
+class LLMContextAggregator(LLMResponseAggregator):
+    def __init__(self, *, context: OpenAILLMContext, **kwargs):
+
+        self._context = context
+        super().__init__(**kwargs)
+
+    async def _push_aggregation(self):
+        if len(self._aggregation) > 0:
+            self._context.add_message({"role": self._role, "content": self._aggregation})
+            frame = OpenAILLMContextFrame(self._context)
+            await self.push_frame(frame)
+
+            # Reset our accumulator state.
+            self._reset()
+
+
+class LLMAssistantContextAggregator(LLMContextAggregator):
+    def __init__(self, context: OpenAILLMContext):
+        super().__init__(
+            messages=[],
+            context=context,
+            role="assistant",
+            start_frame=LLMResponseStartFrame,
+            end_frame=LLMResponseEndFrame,
+            accumulator_frame=TextFrame
+        )
+
+
+class LLMUserContextAggregator(LLMContextAggregator):
+    def __init__(self, context: OpenAILLMContext):
+        super().__init__(
+            messages=[],
+            context=context,
+            role="user",
+            start_frame=UserStartedSpeakingFrame,
+            end_frame=UserStoppedSpeakingFrame,
+            accumulator_frame=TranscriptionFrame,
+            interim_accumulator_frame=InterimTranscriptionFrame
+        )

src/pipecat/processors/aggregators/openai_llm_context.py

@@ -5,10 +5,14 @@
 #
 
 from dataclasses import dataclass
+import io
+import json
 
 from typing import List
 
-from pipecat.frames.frames import Frame
+from PIL import Image
+
+from pipecat.frames.frames import Frame, VisionImageRawFrame
 
 from openai._types import NOT_GIVEN, NotGiven
 
@@ -18,6 +22,17 @@ from openai.types.chat import (
     ChatCompletionMessageParam
 )
 
+# JSON custom encoder to handle bytes arrays so that we can log contexts
+# with images to the console.
+
+
+class CustomEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, io.BytesIO):
+            # Convert the first 8 bytes to an ASCII hex string
+            return (f"{obj.getbuffer()[0:8].hex()}...")
+        return super().default(obj)
+
 
 class OpenAILLMContext:
 
@@ -43,12 +58,40 @@ class OpenAILLMContext:
             })
         return context
 
+    @staticmethod
+    def from_image_frame(frame: VisionImageRawFrame) -> "OpenAILLMContext":
+        """
+        For images, we are deviating from the OpenAI messages shape. OpenAI
+        expects images to be base64 encoded, but other vision models may not.
+        So we'll store the image as bytes and do the base64 encoding as needed
+        in the LLM service.
+        """
+        context = OpenAILLMContext()
+        buffer = io.BytesIO()
+        Image.frombytes(
+            frame.format,
+            frame.size,
+            frame.image
+        ).save(
+            buffer,
+            format="JPEG")
+        context.add_message({
+            "content": frame.text,
+            "role": "user",
+            "data": buffer,
+            "mime_type": "image/jpeg"
+        })
+        return context
+
     def add_message(self, message: ChatCompletionMessageParam):
         self.messages.append(message)
 
     def get_messages(self) -> List[ChatCompletionMessageParam]:
         return self.messages
 
+    def get_messages_json(self) -> str:
+        return json.dumps(self.messages, cls=CustomEncoder)
+
     def set_tool_choice(
         self, tool_choice: ChatCompletionToolChoiceOptionParam | NotGiven
     ):

src/pipecat/processors/aggregators/user_response.py

@@ -8,6 +8,7 @@ from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 from pipecat.frames.frames import (
     Frame,
     InterimTranscriptionFrame,
+    StartInterruptionFrame,
     TextFrame,
     TranscriptionFrame,
     UserStartedSpeakingFrame,
@@ -56,12 +57,9 @@ class ResponseAggregator(FrameProcessor):
         self._end_frame = end_frame
         self._accumulator_frame = accumulator_frame
         self._interim_accumulator_frame = interim_accumulator_frame
-        self._seen_start_frame = False
-        self._seen_end_frame = False
-        self._seen_interim_results = False
 
-        self._aggregation = ""
-        self._aggregating = False
+        # Reset our accumulator state.
+        self._reset()
 
     #
     # Frame processor
@@ -87,10 +85,13 @@ class ResponseAggregator(FrameProcessor):
         send_aggregation = False
 
         if isinstance(frame, self._start_frame):
-            self._seen_start_frame = True
             self._aggregating = True
+            self._seen_start_frame = True
+            self._seen_end_frame = False
+            self._seen_interim_results = False
         elif isinstance(frame, self._end_frame):
             self._seen_end_frame = True
+            self._seen_start_frame = False
 
             # We might have received the end frame but we might still be
             # aggregating (i.e. we have seen interim results but not the final
@@ -120,13 +121,23 @@ class ResponseAggregator(FrameProcessor):
 
     async def _push_aggregation(self):
         if len(self._aggregation) > 0:
-            await self.push_frame(TextFrame(self._aggregation.strip()))
+            frame = TextFrame(self._aggregation.strip())
 
-            # Reset
+            # Reset the aggregation. Reset it before pushing it down, otherwise
+            # if the tasks gets cancelled we won't be able to clear things up.
             self._aggregation = ""
-            self._seen_start_frame = False
-            self._seen_end_frame = False
-            self._seen_interim_results = False
+
+            await self.push_frame(frame)
+
+            # Reset our accumulator state.
+            self._reset()
+
+    def _reset(self):
+        self._aggregation = ""
+        self._aggregating = False
+        self._seen_start_frame = False
+        self._seen_end_frame = False
+        self._seen_interim_results = False
 
 
 class UserResponseAggregator(ResponseAggregator):

src/pipecat/processors/aggregators/vision_image_frame.py

@@ -12,7 +12,7 @@ class VisionImageFrameAggregator(FrameProcessor):
     """This aggregator waits for a consecutive TextFrame and an
     ImageFrame. After the ImageFrame arrives it will output a VisionImageFrame.
 
-    >>> from pipecat.pipeline.frames import ImageFrame
+    >>> from pipecat.frames.frames import ImageFrame
 
     >>> async def print_frames(aggregator, frame):
     ...     async for frame in aggregator.process_frame(frame):

src/pipecat/processors/filters/frame_filter.py

@@ -10,7 +10,7 @@ from pipecat.frames.frames import AppFrame, ControlFrame, Frame, SystemFrame
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
 
 
-class Filter(FrameProcessor):
+class FrameFilter(FrameProcessor):
 
     def __init__(self, types: List[type]):
         super().__init__()

src/pipecat/processors/filters/wake_check_filter.py

@@ -0,0 +1,84 @@
+#
+# Copyright (c) 2024, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+import re
+import time
+
+from enum import Enum
+
+from pipecat.frames.frames import ErrorFrame, Frame, TranscriptionFrame
+from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+
+from loguru import logger
+
+
+class WakeCheckFilter(FrameProcessor):
+    """
+    This filter looks for wake phrases in the transcription frames and only passes through frames
+    after a wake phrase has been detected. It also has a keepalive timeout to allow for a brief
+    period of continued conversation after a wake phrase has been detected.
+    """
+    class WakeState(Enum):
+        IDLE = 1
+        AWAKE = 2
+
+    class ParticipantState:
+        def __init__(self, participant_id: str):
+            self.participant_id = participant_id
+            self.state = WakeCheckFilter.WakeState.IDLE
+            self.wake_timer = 0.0
+            self.accumulator = ""
+
+    def __init__(self, wake_phrases: list[str], keepalive_timeout: float = 3):
+        super().__init__()
+        self._participant_states = {}
+        self._keepalive_timeout = keepalive_timeout
+        self._wake_patterns = []
+        for name in wake_phrases:
+            pattern = re.compile(r'\b' + r'\s*'.join(re.escape(word)
+                                 for word in name.split()) + r'\b', re.IGNORECASE)
+            self._wake_patterns.append(pattern)
+
+    async def process_frame(self, frame: Frame, direction: FrameDirection):
+        try:
+            if isinstance(frame, TranscriptionFrame):
+                p = self._participant_states.get(frame.user_id)
+                if p is None:
+                    p = WakeCheckFilter.ParticipantState(frame.user_id)
+                    self._participant_states[frame.user_id] = p
+
+                # If we have been AWAKE within the last keepalive_timeout seconds, pass
+                # the frame through
+                if p.state == WakeCheckFilter.WakeState.AWAKE:
+                    if time.time() - p.wake_timer < self._keepalive_timeout:
+                        logger.debug(
+                            f"Wake phrase keepalive timeout has not expired. Pushing {frame}")
+                        p.wake_timer = time.time()
+                        await self.push_frame(frame)
+                        return
+                    else:
+                        p.state = WakeCheckFilter.WakeState.IDLE
+
+                p.accumulator += frame.text
+                for pattern in self._wake_patterns:
+                    match = pattern.search(p.accumulator)
+                    if match:
+                        logger.debug(f"Wake phrase triggered: {match.group()}")
+                        # Found the wake word. Discard from the accumulator up to the start of the match
+                        # and modify the frame in place.
+                        p.state = WakeCheckFilter.WakeState.AWAKE
+                        p.wake_timer = time.time()
+                        frame.text = p.accumulator[match.start():]
+                        p.accumulator = ""
+                        await self.push_frame(frame)
+                    else:
+                        pass
+            else:
+                await self.push_frame(frame, direction)
+        except Exception as e:
+            error_msg = f"Error in wake word filter: {e}"
+            logger.error(error_msg)
+            await self.push_error(ErrorFrame(error_msg))

src/pipecat/processors/logger.py

@@ -6,17 +6,22 @@
 
 from pipecat.frames.frames import Frame
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from loguru import logger
+from typing import Optional
+logger = logger.opt(ansi=True)
 
 
 class FrameLogger(FrameProcessor):
-    def __init__(self, prefix="Frame"):
+    def __init__(self, prefix="Frame", color: Optional[str] = None):
         super().__init__()
         self._prefix = prefix
+        self._color = color
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
-        match direction:
-            case FrameDirection.UPSTREAM:
-                print(f"< {self._prefix}: {frame}")
-            case FrameDirection.DOWNSTREAM:
-                print(f"> {self._prefix}: {frame}")
+        dir = "<" if direction is FrameDirection.UPSTREAM else ">"
+        msg = f"{dir} {self._prefix}: {frame}"
+        if self._color:
+            msg = f"<{self._color}>{msg}</>"
+        logger.debug(msg)
+
         await self.push_frame(frame, direction)

src/pipecat/processors/utils/audio.py

@@ -1,25 +0,0 @@
-#
-# Copyright (c) 2024, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-from typing import List
-
-from pipecat.frames.frames import AudioRawFrame
-
-
-def maybe_split_audio_frame(frame: AudioRawFrame, largest_write_size: int) -> List[AudioRawFrame]:
-    """Subdivide large audio frames to enable interruption."""
-    frames: List[AudioRawFrame] = []
-    if len(frame.audio) > largest_write_size:
-        for i in range(0, len(frame.audio), largest_write_size):
-            chunk = frame.audio[i: i + largest_write_size]
-            frames.append(
-                AudioRawFrame(
-                    audio=chunk,
-                    sample_rate=frame.sample_rate,
-                    num_channels=frame.num_channels))
-    else:
-        frames.append(frame)
-    return frames

src/pipecat/serializers/abstract_frame_serializer.py

@@ -1,6 +1,6 @@
 from abc import abstractmethod
 
-from pipecat.pipeline.frames import Frame
+from pipecat.frames.frames import Frame
 
 
 class FrameSerializer:

src/pipecat/serializers/protobuf_serializer.py

@@ -1,14 +1,14 @@
 import dataclasses
 from typing import Text
-from pipecat.pipeline.frames import AudioFrame, Frame, TextFrame, TranscriptionFrame
-import pipecat.pipeline.protobufs.frames_pb2 as frame_protos
+from pipecat.frames.frames import AudioRawFrame, Frame, TextFrame, TranscriptionFrame
+import pipecat.frames.protobufs.frames_pb2 as frame_protos
 from pipecat.serializers.abstract_frame_serializer import FrameSerializer
 
 
 class ProtobufFrameSerializer(FrameSerializer):
     SERIALIZABLE_TYPES = {
         TextFrame: "text",
-        AudioFrame: "audio",
+        AudioRawFrame: "audio",
         TranscriptionFrame: "transcription"
     }
 

src/pipecat/services/ai_services.py

@@ -4,9 +4,7 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
-import array
 import io
-import math
 import wave
 
 from abc import abstractmethod
@@ -18,10 +16,14 @@ from pipecat.frames.frames import (
     EndFrame,
     ErrorFrame,
     Frame,
+    TTSStartedFrame,
+    TTSStoppedFrame,
     TextFrame,
     VisionImageRawFrame,
 )
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor
+from pipecat.utils.audio import calculate_audio_volume
+from pipecat.utils.utils import exp_smoothing
 
 
 class AIService(FrameProcessor):
@@ -64,18 +66,26 @@ class TTSService(AIService):
         else:
             self._current_sentence += frame.text
             if self._current_sentence.strip().endswith((".", "?", "!")):
-                text = self._current_sentence
+                text = self._current_sentence.strip()
                 self._current_sentence = ""
 
         if text:
-            await self.process_generator(self.run_tts(text))
+            await self._push_tts_frames(text)
+
+    async def _push_tts_frames(self, text: str):
+        await self.push_frame(TTSStartedFrame())
+        await self.process_generator(self.run_tts(text))
+        await self.push_frame(TTSStoppedFrame())
+        # We send the original text after the audio. This way, if we are
+        # interrupted, the text is not added to the assistant context.
+        await self.push_frame(TextFrame(text))
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         if isinstance(frame, TextFrame):
             await self._process_text_frame(frame)
         elif isinstance(frame, EndFrame):
             if self._current_sentence:
-                await self.process_generator(self.run_tts(self._current_sentence))
+                await self._push_tts_frames(self._current_sentence)
             await self.push_frame(frame)
         else:
             await self.push_frame(frame, direction)
@@ -85,22 +95,22 @@ class STTService(AIService):
     """STTService is a base class for speech-to-text services."""
 
     def __init__(self,
-                 min_rms: int = 75,
+                 min_volume: float = 0.6,
                  max_silence_secs: float = 0.3,
                  max_buffer_secs: float = 1.5,
                  sample_rate: int = 16000,
                  num_channels: int = 1):
         super().__init__()
-        self._min_rms = min_rms
+        self._min_volume = min_volume
         self._max_silence_secs = max_silence_secs
         self._max_buffer_secs = max_buffer_secs
         self._sample_rate = sample_rate
         self._num_channels = num_channels
         (self._content, self._wave) = self._new_wave()
         self._silence_num_frames = 0
-        # Exponential smoothing
-        self._smoothing_factor = 0.08
-        self._prev_rms = 1 - self._smoothing_factor
+        # Volume exponential smoothing
+        self._smoothing_factor = 0.4
+        self._prev_volume = 1 - self._smoothing_factor
 
     @abstractmethod
     async def run_stt(self, audio: bytes) -> AsyncGenerator[Frame, None]:
@@ -115,28 +125,20 @@ class STTService(AIService):
         ww.setframerate(self._sample_rate)
         return (content, ww)
 
-    def _exp_smoothing(self, value: float, prev_value: float, factor: float) -> float:
-        return prev_value + factor * (value - prev_value)
-
-    def _get_smoothed_volume(self, audio: bytes, prev_rms: float, factor: float) -> float:
-        # https://docs.python.org/3/library/array.html
-        audio_array = array.array('h', audio)
-        squares = [sample**2 for sample in audio_array]
-        mean = sum(squares) / len(audio_array)
-        rms = math.sqrt(mean)
-        return self._exp_smoothing(rms, prev_rms, factor)
+    def _get_smoothed_volume(self, frame: AudioRawFrame) -> float:
+        volume = calculate_audio_volume(frame.audio, frame.sample_rate)
+        return exp_smoothing(volume, self._prev_volume, self._smoothing_factor)
 
     async def _append_audio(self, frame: AudioRawFrame):
         # Try to filter out empty background noise
-        # (Very rudimentary approach, can be improved)
-        rms = self._get_smoothed_volume(frame.audio, self._prev_rms, self._smoothing_factor)
-        if rms >= self._min_rms:
+        volume = self._get_smoothed_volume(frame)
+        if volume >= self._min_volume:
             # If volume is high enough, write new data to wave file
             self._wave.writeframes(frame.audio)
             self._silence_num_frames = 0
         else:
             self._silence_num_frames += frame.num_frames
-        self._prev_rms = rms
+        self._prev_volume = volume
 
         # If buffer is not empty and we have enough data or there's been a long
         # silence, transcribe the audio gathered so far.
@@ -156,6 +158,8 @@ class STTService(AIService):
             self._wave.close()
             await self.push_frame(frame, direction)
         elif isinstance(frame, AudioRawFrame):
+            # In this service we accumulate audio internally and at the end we
+            # push a TextFrame. We don't really want to push audio frames down.
             await self._append_audio(frame)
         else:
             await self.push_frame(frame, direction)
@@ -173,6 +177,7 @@ class ImageGenService(AIService):
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         if isinstance(frame, TextFrame):
+            await self.push_frame(frame, direction)
             await self.process_generator(self.run_image_gen(frame.text))
         else:
             await self.push_frame(frame, direction)

src/pipecat/services/anthropic.py

@@ -4,9 +4,24 @@
 # SPDX-License-Identifier: BSD 2-Clause License
 #
 
-from pipecat.frames.frames import Frame, LLMMessagesFrame, TextFrame
+import os
+import asyncio
+import time
+import base64
+
+from pipecat.frames.frames import (
+    Frame,
+    TextFrame,
+    VisionImageRawFrame,
+    LLMMessagesFrame,
+    LLMFullResponseStartFrame,
+    LLMResponseStartFrame,
+    LLMResponseEndFrame,
+    LLMFullResponseEndFrame
+)
 from pipecat.processors.frame_processor import FrameDirection
 from pipecat.services.ai_services import LLMService
+from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext, OpenAILLMContextFrame
 
 from loguru import logger
 
@@ -20,18 +35,98 @@ except ModuleNotFoundError as e:
 
 
 class AnthropicLLMService(LLMService):
+    """This class implements inference with Anthropic's AI models
+
+    This service translates internally from OpenAILLMContext to the messages format
+    expected by the Anthropic Python SDK. We are using the OpenAILLMContext as a lingua
+    franca for all LLM services, so that it is easy to switch between different LLMs.
+    """
 
     def __init__(
             self,
-            api_key,
-            model="claude-3-opus-20240229",
-            max_tokens=1024):
+            api_key: str,
+            model: str = "claude-3-opus-20240229",
+            max_tokens: int = 1024):
         super().__init__()
-        self.client = AsyncAnthropic(api_key=api_key)
-        self.model = model
-        self.max_tokens = max_tokens
+        self._client = AsyncAnthropic(api_key=api_key)
+        self._model = model
+        self._max_tokens = max_tokens
+
+    def _get_messages_from_openai_context(
+            self, context: OpenAILLMContext):
+        openai_messages = context.get_messages()
+        anthropic_messages = []
+
+        for message in openai_messages:
+            role = message["role"]
+            text = message["content"]
+            if role == "system":
+                role = "user"
+            if message.get("mime_type") == "image/jpeg":
+                # vision frame
+                encoded_image = base64.b64encode(message["data"].getvalue()).decode("utf-8")
+                anthropic_messages.append({
+                    "role": role,
+                    "content": [{
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": message.get("mime_type"),
+                            "data": encoded_image,
+                        }
+                    }, {
+                        "type": "text",
+                        "text": text
+                    }]
+                })
+            else:
+                # text frame
+                anthropic_messages.append({"role": role, "content": content})
+
+        return anthropic_messages
+
+    async def _process_context(self, context: OpenAILLMContext):
+        await self.push_frame(LLMFullResponseStartFrame())
+        try:
+            logger.debug(f"Generating chat: {context.get_messages_json()}")
+
+            messages = self._get_messages_from_openai_context(context)
+
+            start_time = time.time()
+            response = await self._client.messages.create(
+                messages=messages,
+                model=self._model,
+                max_tokens=self._max_tokens,
+                stream=True)
+            logger.debug(f"Anthropic LLM TTFB: {time.time() - start_time}")
+            async for event in response:
+                # logger.debug(f"Anthropic LLM event: {event}")
+                if (event.type == "content_block_delta"):
+                    await self.push_frame(LLMResponseStartFrame())
+                    await self.push_frame(TextFrame(event.delta.text))
+                    await self.push_frame(LLMResponseEndFrame())
+
+        except Exception as e:
+            logger.error(f"Exception: {e}")
+        finally:
+            await self.push_frame(LLMFullResponseEndFrame())
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
+        context = None
+
+        if isinstance(frame, OpenAILLMContextFrame):
+            context: OpenAILLMContext = frame.context
+        elif isinstance(frame, LLMMessagesFrame):
+            context = OpenAILLMContext.from_messages(frame.messages)
+        elif isinstance(frame, VisionImageRawFrame):
+            context = OpenAILLMContext.from_image_frame(frame)
+        else:
+            await self.push_frame(frame, direction)
+
+        if context:
+            await self._process_context(context)
+
+    async def x_process_frame(self, frame: Frame, direction: FrameDirection):
         if isinstance(frame, LLMMessagesFrame):
             stream = await self.client.messages.create(
                 max_tokens=self.max_tokens,

src/pipecat/services/azure.py

@@ -11,6 +11,7 @@ import io
 from PIL import Image
 from typing import AsyncGenerator
 
+from numpy import str_
 from openai import AsyncAzureOpenAI
 
 from pipecat.frames.frames import AudioRawFrame, ErrorFrame, Frame, URLImageRawFrame
@@ -45,7 +46,7 @@ class AzureTTSService(TTSService):
         self._voice = voice
 
     async def run_tts(self, text: str) -> AsyncGenerator[Frame, None]:
-        logger.debug(f"Transcribing text: {text}")
+        logger.debug(f"Generating TTS: {text}")
 
         ssml = (
             "<speak version='1.0' xml:lang='en-US' xmlns='http://www.w3.org/2001/10/synthesis' "
@@ -73,17 +74,18 @@ class AzureLLMService(BaseOpenAILLMService):
     def __init__(
             self,
             *,
-            api_key,
-            endpoint,
-            api_version="2023-12-01-preview",
-            model):
-        super().__init__(api_key=api_key, model=model)
+            api_key: str,
+            endpoint: str,
+            model: str,
+            api_version: str = "2023-12-01-preview"):
+        # Initialize variables before calling parent __init__() because that
+        # will call create_client() and we need those values there.
         self._endpoint = endpoint
         self._api_version = api_version
-        self._model: str = model
+        super().__init__(api_key=api_key, model=model)
 
     def create_client(self, api_key=None, base_url=None):
-        self._client = AsyncAzureOpenAI(
+        return AsyncAzureOpenAI(
             api_key=api_key,
             azure_endpoint=self._endpoint,
             api_version=self._api_version,
@@ -95,12 +97,12 @@ class AzureImageGenServiceREST(ImageGenService):
     def __init__(
         self,
         *,
-        api_version="2023-06-01-preview",
-        image_size: str,
         aiohttp_session: aiohttp.ClientSession,
-        api_key,
-        endpoint,
-        model,
+        image_size: str,
+        api_key: str,
+        endpoint: str,
+        model: str,
+        api_version="2023-06-01-preview",
     ):
         super().__init__()