Refactor to use frame-based interruption control

- Add EnableInterruptionsFrame custom frame for pipeline-based control - Subclass VADUserTurnStartStrategy as DynamicVADUserTurnStartStrategy - Use task.queue_frame() to toggle interruptions idiomatically - Follows same pattern as MixerEnableFrame in 23-bot-background-sound.py
Add example demonstrating dynamic interruption toggling
2026-01-14 11:39:45 +08:00 · 2026-01-14 11:23:29 +08:00 · 2026-01-13 17:02:41 -08:00 · 2026-01-13 16:59:46 -08:00 · 2026-01-14 00:49:15 +00:00 · 2026-01-13 16:48:07 -08:00
653 changed files with 10685 additions and 4760 deletions
--- a/.github/workflows/coverage.yaml
+++ b/.github/workflows/coverage.yaml
@@ -33,7 +33,7 @@ jobs:

      - name: Install dependencies
        run: |
-          uv sync --group dev --extra anthropic --extra aws --extra google --extra langchain
+          uv sync --group dev --extra anthropic --extra aws --extra google --extra langchain --extra websocket

      - name: Run tests with coverage
        run: |
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@@ -37,7 +37,7 @@ jobs:

      - name: Install dependencies
        run: |
-          uv sync --group dev --extra anthropic --extra aws --extra google --extra langchain
+          uv sync --group dev --extra anthropic --extra aws --extra google --extra langchain --extra websocket

      - name: Test with pytest
        run: |
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,518 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 <!-- towncrier release notes start -->

+## [0.0.99] - 2026-01-13
+
+### Added
+
+- Introducing user turn strategies. User turn strategies indicate when the user
+  turn starts or stops. In conversational agents, these are often referred to
+  as start/stop speaking or turn-taking plans or policies.
+
+  User turn start strategies indicate when the user starts speaking (e.g.
+  using VAD events or when a user says one or more words).
+
+  User turn stop strategies indicate when the user stops speaking (e.g. using
+  an end-of-turn detection model or by observing incoming transcriptions).
+
+  A list of strategies can be specified for both strategies; strategies are
+  evaluated in order until one evaluates to true.
+
+    Available user turn start strategies:
+      - VADUserTurnStartStrategy
+      - TranscriptionUserTurnStartStrategy
+      - MinWordsUserTurnStartStrategy
+      - ExternalUserTurnStartStrategy
+
+    Available user turn stop strategies:
+      - TranscriptionUserTurnStopStrategy
+      - TurnAnalyzerUserTurnStopStrategy
+      - ExternalUserTurnStopStrategy
+
+    The default strategies are:
+
+      - start: [VADUserTurnStartStrategy, TranscriptionUserTurnStartStrategy]
+      - stop: [TranscriptionUserTurnStopStrategy]
+
+  urn strategies are configured when setting up `LLMContextAggregatorPair`.
+  For example:
+
+    ```python
+    context_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(
+            user_turn_strategies=UserTurnStrategies(
+                stop=[
+                    TurnAnalyzerUserTurnStopStrategy(
+turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams())
+                    )
+                ],
+            )
+        ),
+    )
+    ```
+
+  In order to use the user turn strategies you must update to the new
+  universal `LLMContext` and `LLMContextAggregatorPair`.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- Added `RNNoiseFilter` for real-time noise suppression using RNNoise neural
+  network via pyrnnoise library.
+  (PR [#3205](https://github.com/pipecat-ai/pipecat/pull/3205))
+
+- Added `GrokRealtimeLLMService` for xAI's Grok Voice Agent API with real-time
+  voice conversations:
+
+    - Support for real-time audio streaming with WebSocket connection
+    - Built-in server-side VAD (Voice Activity Detection)
+    - Multiple voice options: Ara, Rex, Sal, Eve, Leo
+    - Built-in tools support: web_search, x_search, file_search
+    - Custom function calling with standard Pipecat tools schema
+    - Configurable audio formats (PCM at 8kHz-48kHz)
+  (PR [#3267](https://github.com/pipecat-ai/pipecat/pull/3267))
+
+- Added an approximation of TTFB for Ultravox.
+  (PR [#3268](https://github.com/pipecat-ai/pipecat/pull/3268))
+
+- Added a new `AudioContextTTSService` to the TTS service base classes. The
+  `AudioContextWordTTSService` now inherits from `AudioContextTTSService` and
+  `WebsocketWordTTSService`.
+  (PR [#3289](https://github.com/pipecat-ai/pipecat/pull/3289))
+
+- `LLMUserAggregator` now exposes the following events:
+     - `on_user_turn_started`: triggered when a user turn starts
+     - `on_user_turn_stopped`: triggered when a user turn ends
+     - `on_user_turn_stop_timeout`: triggered when a user turn does not stop
+        and times out
+  (PR [#3291](https://github.com/pipecat-ai/pipecat/pull/3291))
+
+- Introducing user mute strategies. User mute strategies indicate when user
+  input should be muted based on the current system state.
+
+  In conversational agents, user mute strategies are used to prevent user
+  input from interrupting bot speech, tool execution, or other critical system
+  operations.
+
+  A list of strategies can be specified; all strategies are evaluated for
+  every frame so that each strategy can maintain its internal state. A user
+  frame is muted if any of the configured strategies indicates it should be
+  muted.
+
+    Available user mute strategies:
+
+    * `FirstSpeechUserMuteStrategy`
+    * `MuteUntilFirstBotCompleteUserMuteStrategy`
+    * `AlwaysUserMuteStrategy`
+    * `FunctionCallUserMuteStrategy`
+
+  User mute strategies replace the legacy `STTMuteFilter` and provide a more
+  flexible and composable approach to muting user input.
+
+  User mute strategies are configured when setting up the
+  `LLMContextAggregatorPair`. For example:
+
+    ```python
+    context_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(
+            user_mute_strategies=[
+                FirstSpeechUserMuteStrategy(),
+            ]
+        ),
+    )
+    ```
+
+  In order to use user mute strategies you should update to the new universal
+  `LLMContext` and `LLMContextAggregatorPair`.
+  (PR [#3292](https://github.com/pipecat-ai/pipecat/pull/3292))
+
+- Added `use_ssl` parameter to `NvidiaSTTService`, `NvidiaSegmentedSTTService`
+  and `NvidiaTTSService`.
+  (PR [#3300](https://github.com/pipecat-ai/pipecat/pull/3300))
+
+- Added `enable_interruptions` constructor argument to all user turn
+  strategies. This tells the `LLMUserAggregator` to push or not push an
+  `InterruptionFrame`.
+  (PR [#3316](https://github.com/pipecat-ai/pipecat/pull/3316))
+
+- Added `split_sentences` parameter to `SpeechmaticsSTTService` to control
+  sentence splitting behavior for finals on sentence boundaries.
+  (PR [#3328](https://github.com/pipecat-ai/pipecat/pull/3328))
+
+- Added word-level timestamp support to `AzureTTSService` for accurate
+  text-to-audio synchronization.
+  (PR [#3334](https://github.com/pipecat-ai/pipecat/pull/3334))
+
+- Added `pronunciation_dict_id` parameter to `CartesiaTTSService.InputParams`
+  and `CartesiaHttpTTSService.InputParams` to support Cartesia's pronunciation
+  dictionary feature for custom pronunciations.
+  (PR [#3346](https://github.com/pipecat-ai/pipecat/pull/3346))
+
+- Added support for using the HeyGen LiveAvatar API with the `HeyGenTransport`
+  (see https://www.liveavatar.com/).
+  (PR [#3357](https://github.com/pipecat-ai/pipecat/pull/3357))
+
+- Added image support to `OpenAIRealtimeLLMService` via `InputImageRawFrame`:
+    - New `start_video_paused` parameter to control initial video input state
+    - New `video_frame_detail` parameter to set image processing quality
+  ("auto",
+      "low", or "high"). This corresponds to OpenAI Realtime's `image_detail`
+      parameter.
+    - `set_video_input_paused()` method to pause/resume video input at runtime
+    - `set_video_frame_detail()` method to adjust video frame quality
+       dynamically
+    - Automatic rate limiting (1 frame per second) to prevent API overload
+  (PR [#3360](https://github.com/pipecat-ai/pipecat/pull/3360))
+
+- Added `UserTurnProcessor`, a frame processor built on `UserTurnController`
+  that pushes `UserStartedSpeakingFrame` and `UserStoppedSpeakingFrame` frames
+  and interruptions based on the controller's user turn strategies.
+  (PR [#3372](https://github.com/pipecat-ai/pipecat/pull/3372))
+
+- Added `UserTurnController` to manage user turns. It emits
+  `on_user_turn_started`, `on_user_turn_stopped`, and
+  `on_user_turn_stop_timeout` events, and can be integrated into processors to
+  detect and handle user turns. `LLMUserAggregator` and `UserTurnProcessor` are
+  implemented using this controller.
+  (PR [#3372](https://github.com/pipecat-ai/pipecat/pull/3372))
+
+- Added `should_interrupt` property to `DeepgramFluxSTTService`,
+  `DeepgramSTTService`, and `SpeechmaticsSTTService` to configure whether the
+  bot should be interrupted when the external service detects user speech.
+  (PR [#3374](https://github.com/pipecat-ai/pipecat/pull/3374))
+
+- `LLMAssistantAggregator` now exposes the following events:
+     - `on_assistant_turn_started`: triggered when the assistant turn starts
+     - `on_assistant_turn_stopped`: triggered when the assistant turn ends
+     - `on_assistant_thought`: triggered when there's an assistant thought
+  available
+  (PR [#3385](https://github.com/pipecat-ai/pipecat/pull/3385))
+
+- Added `KrispVivaTurn` analyzer for end of turn detection using the Krisp VIVA
+  SDK (requires `krisp_audio`).
+  (PR [#3391](https://github.com/pipecat-ai/pipecat/pull/3391))
+
+- Added support for setting up a pipeline task from external files. You can now
+  register custom pipeline task setup files by setting the
+  `PIPECAT_SETUP_FILES` environment variable. This variable should contain a
+  colon-separated list of Python files (e.g. `export
+  PIPECAT_SETUP_FILES="setup1.py:setup.py:..."`). Each file must define a
+  function with the following signature:
+
+    ```python
+    async def setup_pipeline_task(task: PipelineTask):
+        ...
+    ```
+  (PR [#3397](https://github.com/pipecat-ai/pipecat/pull/3397))
+
+- Added a keepalive task for `InworldTTSService` to keep the service connected
+  in the event of no generations for longer periods of time.
+  (PR [#3403](https://github.com/pipecat-ai/pipecat/pull/3403))
+
+- Added `enable_vad` to `Params` for use in the `GladiaSTTService`. When
+  enabled, `GladiaSTTService` acts as the turn controller, emitting
+  `UserStartedSpeakingFrame`, `UserStoppedSpeakingFrame`, and optionally
+  `InterruptionFrame`.
+  (PR [#3404](https://github.com/pipecat-ai/pipecat/pull/3404))
+
+- Added `should_interrupt` property to `GladiaSTTService` to configure whether
+  the bot should be interrupted when the external service detects user speech.
+  (PR [#3404](https://github.com/pipecat-ai/pipecat/pull/3404))
+
+- Added `VonageFrameSerializer` for the Vonage Video API Audio Connector
+  WebSocket protocol.
+  (PR [#3410](https://github.com/pipecat-ai/pipecat/pull/3410))
+
+- Added `append_trailing_space` parameter to `TTSService` to automatically
+  append a trailing space to text before sending to TTS, helping prevent some
+  services from vocalizing trailing punctuation.
+  (PR [#3424](https://github.com/pipecat-ai/pipecat/pull/3424))
+
+### Changed
+
+- Updated `ElevenLabsRealtimeSTTService` to accept the
+  `include_language_detection` parameter to detect language.
+    ```python
+      stt = ElevenLabsRealtimeSTTService(
+          api_key=os.getenv("ELEVENLABS_API_KEY"),
+          include_language_detection=True
+      )
+    ```
+  (PR [#3216](https://github.com/pipecat-ai/pipecat/pull/3216))
+
+- Updated `SpeechmaticsSTTService` to use new Python Voice SDK with improved
+  VAD, Smart Turn capabilities, and brings dramatic improvements to latency
+  without any impact on accuracy. Use the `turn_detection_mode` parameter to control
+  the endpointing of speech, with `TurnDetectionMode.EXTERNAL` (default),
+  `TurnDetectionMode.ADAPTIVE`, or `TurnDetectionMode.SMART_TURN`.
+    ```python
+      stt = SpeechmaticsSTTService(
+          api_key=os.getenv("SPEECHMATICS_API_KEY"),
+          params=SpeechmaticsSTTService.InputParams(
+              language=Language.EN,
+turn_detection_mode=SpeechmaticsSTTService.TurnDetectionMode.ADAPTIVE,
+              speaker_active_format="<{speaker_id}>{text}</{speaker_id}>",
+          ),
+      )
+    ```
+  (PR [#3225](https://github.com/pipecat-ai/pipecat/pull/3225))
+
+- `daily-python` updated to 0.23.0.
+  (PR [#3257](https://github.com/pipecat-ai/pipecat/pull/3257))
+
+- `TranscriptionFrame` and `InterimTranscriptionFrame` produced by
+  `DailyTransport` now include the transport source (i.e., the originating
+  audio track).
+  (PR [#3257](https://github.com/pipecat-ai/pipecat/pull/3257))
+
+- Updates to Inworld TTS services:
+
+    - Improved `InworldTTSService`'s websocket implementation to better flush
+      and close context to better handle long inputs.
+    - Improved docstrings for `InworldTTSService` and `InworldHttpTTSService`.
+  (PR [#3288](https://github.com/pipecat-ai/pipecat/pull/3288))
+
+- Updated `DeepgramSTTService` to push user started/stopped speaking and
+  interruption frames when `vad_enabled` is set to true. This centralizes the
+  frames into the service, removing the need to have your application code
+  handle Deepgram's events and push these frames.
+  (PR [#3314](https://github.com/pipecat-ai/pipecat/pull/3314))
+
+- Added encoding validation to `DeepgramTTSService` to prevent unsupported
+  encodings from reaching the API. The service now raises `ValueError` at
+  initialization with a clear error message.
+  (PR [#3329](https://github.com/pipecat-ai/pipecat/pull/3329))
+
+- Updated `read_audio_frame` & `read_video_frame` methods in
+  `SmallWebRTCClient` to check if the track is enabled before logging a
+  warning.
+  (PR [#3336](https://github.com/pipecat-ai/pipecat/pull/3336))
+
+- Updated `CartesiaTTSService` to support setting `language=None`, resulting in
+  Cartesia auto-detecting the language of the conversation.
+  (PR [#3366](https://github.com/pipecat-ai/pipecat/pull/3366))
+
+- The bundled Smart Turn weights are now updated to v3.2, which has better
+  handling of short utterances, and is more robust against background noise.
+  (PR [#3367](https://github.com/pipecat-ai/pipecat/pull/3367))
+
+- Updated `SpeechmaticsSTTService` dependency to `speechmatics-voice[smart]>=0.2.6`
+  (PR [#3371](https://github.com/pipecat-ai/pipecat/pull/3371))
+
+- Smart Turn now takes into account `vad_start_seconds` when buffering audio,
+  meaning that the start of the turn audio is not cut off. This improves
+  accuracy for short utterances.
+    - The default value of `pre_speech_ms` is now set to 500ms for Smart Turn.
+  (PR [#3377](https://github.com/pipecat-ai/pipecat/pull/3377))
+
+- Improved Krisp SDK management to allow `KrispVivaTurn` and `KrispVivaFilter`
+  to share a single SDK instance within the same process.
+  (PR [#3391](https://github.com/pipecat-ai/pipecat/pull/3391))
+
+- Updated default model for `GroqTTSService` to `canopylabs/orpheus-v1-english`
+  and voice ID to `autumn`.
+  (PR [#3399](https://github.com/pipecat-ai/pipecat/pull/3399))
+
+- Enhanced `FastAPIWebsocketTransport` with optional protocol-level audio
+  packetization via the `fixed_audio_packet_size` parameter to support media
+  endpoints requiring strict framing and real-time pacing.
+  (PR [#3410](https://github.com/pipecat-ai/pipecat/pull/3410))
+
+- `DeepgramTTSService` and `RimeTTSService` now set `append_trailing_space` to
+  `True` to prevent punctuation (e.g., “dot”) from being pronounced.
+  (PR [#3424](https://github.com/pipecat-ai/pipecat/pull/3424))
+
+- Updated `GeminiLiveLLMService` to push `LLMThoughtStartFrame`,
+  `LLMThoughtTextFrame`, and `LLMThoughtEndFrame` when the model returns
+  thought content.
+  (PR [#3431](https://github.com/pipecat-ai/pipecat/pull/3431))
+
+### Deprecated
+
+- `pipecat.audio.interruptions.MinWordsInterruptionStrategy` is deprecated. Use
+  `pipecat.turns.user_start.MinWordsUserTurnStartStrategy` with
+  `LLMUserAggregator`'s new `user_turn_strategies` parameter instead.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- `FrameProcessor.interruption_strategies` is deprecated, use
+  `LLMUserAggregator`'s new `user_turn_strategies` parameter instead.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- The `LLMUserAggregatorParams` and `LLMAssistantAggregatorParams` classes in
+  `pipecat.processors.aggregators.llm_response` are now deprecated. Use the new
+  universal `LLMContext` and `LLMContextAggregatorPair` instead.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- Deprecated the `emulated` field in the `UserStartedSpeakingFrame` and
+  `UserStoppedSpeakingFrame` frames.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- `EmulateUserStartedSpeakingFrame` and `EmulateUserStoppedSpeakingFrame`
+  frames are deprecated.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- ⚠️ `TransportParams.turn_analyzer` is deprecated and might result in
+  unexpected behavior, use `LLMUserAggregator`'s new `user_turn_strategies`
+  parameter instead.
+  (PR [#3045](https://github.com/pipecat-ai/pipecat/pull/3045))
+
+- For `SpeechmaticsSTTService`, the `end_of_utterance_mode` parameter is
+  deprecated. Use the new `turn_detection_mode` parameter instead, with
+  `TurnDetectionMode.EXTERNAL`,`TurnDetectionMode.ADAPTIVE`, or
+  `TurnDetectionMode.SMART_TURN`. The `enable_vad` parameter is also
+  deprecated and is inferred from the `turn_detection_mode`.
+  (PR [#3225](https://github.com/pipecat-ai/pipecat/pull/3225))
+
+- `OpenAILLMContext` and its associated things (context aggregators, etc.) are
+  now deprecated in favor of the universal `LLMContext` and its associated
+  things.
+
+  From the developer's point of view, switching to using `LLMContext`
+  machinery will usually be a matter of going from this:
+
+    ```python
+    context = OpenAILLMContext(messages, tools)
+    context_aggregator = llm.create_context_aggregator(context)
+    ```
+
+    To this:
+
+    ```
+    context = LLMContext(messages, tools)
+    context_aggregator = LLMContextAggregatorPair(context)
+    ```
+  (PR [#3263](https://github.com/pipecat-ai/pipecat/pull/3263))
+
+- `STTMuteFilter` is deprecated and will be removed in a future version. Use
+  `LLMUserAggregator`'s new `user_mute_strategies` instead.
+  (PR [#3292](https://github.com/pipecat-ai/pipecat/pull/3292))
+
+- `FrameProcessor.interruptions_allowed` is now deprecated, use
+  `LLMUserAggregator`'s new parameter `user_mute_strategies` instead.
+  (PR [#3297](https://github.com/pipecat-ai/pipecat/pull/3297))
+
+- `PipelineParams.allow_interruptions` is now deprecated, use
+  `LLMUserAggregator`'s new parameter `user_turn_strategies` instead. For
+  example, to disable interruptions but still get user turns you can do:
+
+    ```python
+    context_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(
+            user_turn_strategies=UserTurnStrategies(
+start=[TranscriptionUserTurnStartStrategy(enable_interruptions=False)],
+            ),
+        ),
+    )
+    ```
+  (PR [#3297](https://github.com/pipecat-ai/pipecat/pull/3297))
+
+- `TranscriptProcessor` and related data classes and frames
+  (`TranscriptionMessage`, `ThoughtTranscriptionMessage`,
+  `TranscriptionUpdateFrame`) are deprecated. Use `LLMUserAggregator`'s and
+  `LLMAssistantAggregator`'s new events (`on_user_turn_stopped` and
+  `on_assistant_turn_stopped`) instead.
+  (PR [#3385](https://github.com/pipecat-ai/pipecat/pull/3385))
+
+- Deprecated support for the `vad_events` `LiveOptions` in
+  `DeepgramSTTService`. Instead, use a local Silero VAD for VAD events.
+  Additionally, deprecated `should_interrupt` which will be removed along with
+  `vad_events` support in a future release.
+  (PR [#3386](https://github.com/pipecat-ai/pipecat/pull/3386))
+
+- Loading external observers from files is deprecated, use the new pipeline
+  task setup files and `PIPECAT_SETUP_FILES` environment variable instead.
+  (PR [#3397](https://github.com/pipecat-ai/pipecat/pull/3397))
+
+### Fixed
+
+- Improved error handling in `ElevenLabsRealtimeSTTService`
+  - Fixed an issue in `ElevenLabsRealtimeSTTService` causing an infinite loop
+  that blocks the process if the websocket disconnects due to an error
+  (PR [#3233](https://github.com/pipecat-ai/pipecat/pull/3233))
+
+- Fixed a bug in `STTMuteFilter` where the user was not always muted during
+  function calls, especially when there were multiple simultaneous calls.
+  (PR [#3292](https://github.com/pipecat-ai/pipecat/pull/3292))
+
+- Fixed a `RNNoiseFilter` issue that would cause a "[Errno 12] Cannot allocate
+  memory" error when processing silence audio frames.
+  (PR [#3322](https://github.com/pipecat-ai/pipecat/pull/3322))
+
+- Updated `SpeechmaticsSTTService` for version `0.0.99+`:
+    - Fixed `SpeechmaticsSTTService` to listen for `VADUserStoppedSpeakingFrame`
+      in order to finalize transcription.
+    - Default to `TurnDetectionMode.FIXED` for Pipecat-controlled end of turn
+      detection.
+    - Only emit VAD + interruption frames if VAD is enabled within the plugin
+      (modes other than `TurnDetectionMode.FIXED` or `TurnDetectionMode.EXTERNAL`).
+  (PR [#3328](https://github.com/pipecat-ai/pipecat/pull/3328))
+
+- Fixed an issue with function calling where a handler failing to invoke its
+  result callback could leave the context stuck in IN_PROGRESS, causing LLM
+  inference for subsequent function call results to block while waiting on the
+  unresolved call.
+  (PR [#3343](https://github.com/pipecat-ai/pipecat/pull/3343))
+
+- Fixed an issue with DeepgramTTSService where the model would output "Dot"
+  instead of a period in some circumstances.
+  (PR [#3345](https://github.com/pipecat-ai/pipecat/pull/3345))
+
+- Fixed an issue in `traced_stt` where `model_name` in OpenTelemetry appears as
+  `unknown`.
+  (PR [#3351](https://github.com/pipecat-ai/pipecat/pull/3351))
+
+- Fixed an issue in GeminiLiveLLMService where TranscriptionFrames were
+  occasionally not pushed.
+  (PR [#3356](https://github.com/pipecat-ai/pipecat/pull/3356))
+
+- Fixed potential memory leaks and initialization issues in `KrispVivaFilter`
+  by improving SDK lifecycle management.
+  (PR [#3391](https://github.com/pipecat-ai/pipecat/pull/3391))
+
+- Fixed timing issue in `BaseOutputTransport` where the bot speaking flag was
+  set after awaiting, allowing the event loop to re-enter the method before the
+  guard was set.
+  (PR [#3400](https://github.com/pipecat-ai/pipecat/pull/3400))
+
+- Fixed an issue in `traced_llm` where `model_name` in OpenTelemetry appears as
+  `unknown`.
+  (PR [#3422](https://github.com/pipecat-ai/pipecat/pull/3422))
+
+- Fixed an issue in `traced_tts`, `traced_gemini_live`, and
+  `traced_openai_realtime` where `model_name` in OpenTelemetry appears as
+  `unknown`.
+  (PR [#3428](https://github.com/pipecat-ai/pipecat/pull/3428))
+
+- Fixed `request_image_frame` (for backwards compatibility) and restored
+  function-call–related fields in `UserImageRequestFrame` and
+  `UserImageRawFrame`, preventing a case where adding a non-LLM message to the
+  context could trigger duplicate LLM inferences (on image arrival and on
+  function-call result), potentially causing an infinite inference loop.
+  (PR [#3430](https://github.com/pipecat-ai/pipecat/pull/3430))
+
+- Fixed `LLMContext.create_audio_message()` by correcting an internal helper
+  that was incorrectly declared async while being run in `asyncio.to_thread()`.
+  (PR [#3435](https://github.com/pipecat-ai/pipecat/pull/3435))
+
+### Other
+
+- Added `52-live-transcription.py` foundational example demonstrating live
+  transcription and translation from English to Spanish. In this example, the
+  bot is not interruptible: as the user continues speaking, English
+  transcriptions are queued, and the bot continuously translates and speaks
+  each queued sentence in Spanish without being interrupted by new user speech.
+  (PR [#3316](https://github.com/pipecat-ai/pipecat/pull/3316))
+
+- Added a new foundational example `53-concurrent-llm-evaluation.py` that shows
+  how to use `UserTurnProcessor`.
+  (PR [#3372](https://github.com/pipecat-ai/pipecat/pull/3372))
+
+- Added a new foundational example `28-user-assistant-turns.py` that shows how
+  to use the new `LLMUserAggregator` and `LLMAssistantAggregator` events to
+  gather a conversation transcript.
+  (PR [#3385](https://github.com/pipecat-ai/pipecat/pull/3385))
+
 ## [0.0.98] - 2025-12-17

 ### Added
--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 BSD 2-Clause License

-Copyright (c) 2024–2025, Daily
+Copyright (c) 2024–2026, Daily

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
--- a/README.md
+++ b/README.md
@@ -78,7 +78,7 @@ Catch new features, interviews, and how-tos on our [Pipecat TV](https://www.yout
 | Text-to-Speech      | [Async](https://docs.pipecat.ai/server/services/tts/asyncai), [AWS](https://docs.pipecat.ai/server/services/tts/aws), [Azure](https://docs.pipecat.ai/server/services/tts/azure), [Cartesia](https://docs.pipecat.ai/server/services/tts/cartesia), [Deepgram](https://docs.pipecat.ai/server/services/tts/deepgram), [ElevenLabs](https://docs.pipecat.ai/server/services/tts/elevenlabs), [Fish](https://docs.pipecat.ai/server/services/tts/fish), [Google](https://docs.pipecat.ai/server/services/tts/google), [Gradium](https://docs.pipecat.ai/server/services/tts/gradium), [Groq](https://docs.pipecat.ai/server/services/tts/groq), [Hume](https://docs.pipecat.ai/server/services/tts/hume), [Inworld](https://docs.pipecat.ai/server/services/tts/inworld), [LMNT](https://docs.pipecat.ai/server/services/tts/lmnt), [MiniMax](https://docs.pipecat.ai/server/services/tts/minimax), [Neuphonic](https://docs.pipecat.ai/server/services/tts/neuphonic), [NVIDIA Riva](https://docs.pipecat.ai/server/services/tts/riva), [OpenAI](https://docs.pipecat.ai/server/services/tts/openai), [Piper](https://docs.pipecat.ai/server/services/tts/piper), [PlayHT](https://docs.pipecat.ai/server/services/tts/playht), [Rime](https://docs.pipecat.ai/server/services/tts/rime), [Sarvam](https://docs.pipecat.ai/server/services/tts/sarvam), [Speechmatics](https://docs.pipecat.ai/server/services/tts/speechmatics), [XTTS](https://docs.pipecat.ai/server/services/tts/xtts) |
 | Speech-to-Speech    | [AWS Nova Sonic](https://docs.pipecat.ai/server/services/s2s/aws), [Gemini Multimodal Live](https://docs.pipecat.ai/server/services/s2s/gemini), [Grok Voice Agent](https://docs.pipecat.ai/server/services/s2s/grok), [OpenAI Realtime](https://docs.pipecat.ai/server/services/s2s/openai), [Ultravox](https://docs.pipecat.ai/server/services/s2s/ultravox),                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | Transport           | [Daily (WebRTC)](https://docs.pipecat.ai/server/services/transport/daily), [FastAPI Websocket](https://docs.pipecat.ai/server/services/transport/fastapi-websocket), [SmallWebRTCTransport](https://docs.pipecat.ai/server/services/transport/small-webrtc), [WebSocket Server](https://docs.pipecat.ai/server/services/transport/websocket-server), Local                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| Serializers         | [Plivo](https://docs.pipecat.ai/server/utilities/serializers/plivo), [Twilio](https://docs.pipecat.ai/server/utilities/serializers/twilio), [Telnyx](https://docs.pipecat.ai/server/utilities/serializers/telnyx)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| Serializers         | [Exotel](https://docs.pipecat.ai/server/utilities/serializers/exotel), [Plivo](https://docs.pipecat.ai/server/utilities/serializers/plivo), [Twilio](https://docs.pipecat.ai/server/utilities/serializers/twilio), [Telnyx](https://docs.pipecat.ai/server/utilities/serializers/telnyx), [Vonage](https://docs.pipecat.ai/server/utilities/serializers/vonage)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
 | Video               | [HeyGen](https://docs.pipecat.ai/server/services/video/heygen), [Tavus](https://docs.pipecat.ai/server/services/video/tavus), [Simli](https://docs.pipecat.ai/server/services/video/simli)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 | Memory              | [mem0](https://docs.pipecat.ai/server/services/memory/mem0)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 | Vision & Image      | [fal](https://docs.pipecat.ai/server/services/image-generation/fal), [Google Imagen](https://docs.pipecat.ai/server/services/image-generation/fal), [Moondream](https://docs.pipecat.ai/server/services/vision/moondream)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
--- a/changelog/3045.added.md
+++ b/changelog/3045.added.md
@@ -1,42 +0,0 @@
- Introducing user turn strategies. User turn strategies indicate when the user turn starts or stops. In conversational agents, these are often referred to as start/stop speaking or turn-taking plans or policies.
-
-  User turn start strategies indicate when the user starts speaking (e.g. using VAD events or when a user says one or more words).
-
-  User turn stop strategies indicate when the user stops speaking (e.g. using an end-of-turn detection model or by observing incoming transcriptions).
-
-  A list of strategies can be specified for both strategies; strategies are evaluated in order until one evaluates to true.
-
-  Available user turn start strategies:
-    - VADUserTurnStartStrategy
-    - TranscriptionUserTurnStartStrategy
-    - MinWordsUserTurnStartStrategy
-    - ExternalUserTurnStartStrategy
-
-  Available user turn stop strategies:
-    - TranscriptionUserTurnStopStrategy
-    - TurnAnalyzerUserTurnStopStrategy
-    - ExternalUserTurnStopStrategy
-
-  The default strategies are:
-
-    - start: [VADUserTurnStartStrategy, TranscriptionUserTurnStartStrategy]
-    - stop: [TranscriptionUserTurnStopStrategy]
-
-  Turn strategies are configured when setting up `LLMContextAggregatorPair`. For example:
-
-  ```python
-  context_aggregator = LLMContextAggregatorPair(
-      context,
-      user_params=LLMUserAggregatorParams(
-          user_turn_strategies=UserTurnStrategies(
-              stop=[
-                  TurnAnalyzerUserTurnStopStrategy(
-                      turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams())
-                  )
-              ],
-          )
-      ),
-  )
-  ```
-
-  In order to use the user turn strategies you must update to the new universal `LLMContext` and `LLMContextAggregatorPair`.
--- a/changelog/3045.deprecated.2.md
+++ b/changelog/3045.deprecated.2.md
@@ -1 +0,0 @@
- ⚠️ `TransportParams.turn_analyzer` is deprecated and might result in unexpected behavior, use `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
--- a/changelog/3045.deprecated.3.md
+++ b/changelog/3045.deprecated.3.md
@@ -1 +0,0 @@
- `FrameProcessor.interruption_strategies` is deprecated, use `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
--- a/changelog/3045.deprecated.4.md
+++ b/changelog/3045.deprecated.4.md
@@ -1 +0,0 @@
- `EmulateUserStartedSpeakingFrame` and `EmulateUserStoppedSpeakingFrame` frames are deprecated.
--- a/changelog/3045.deprecated.5.md
+++ b/changelog/3045.deprecated.5.md
@@ -1 +0,0 @@
- Deprecated the `emulated` field in the `UserStartedSpeakingFrame` and `UserStoppedSpeakingFrame` frames.
--- a/changelog/3045.deprecated.6.md
+++ b/changelog/3045.deprecated.6.md
@@ -1 +0,0 @@
- The `LLMUserAggregatorParams` and `LLMAssistantAggregatorParams` classes in `pipecat.processors.aggregators.llm_response` are now deprecated. Use the new universal `LLMContext` and `LLMContextAggregatorPair` instead.
--- a/changelog/3045.deprecated.md
+++ b/changelog/3045.deprecated.md
@@ -1 +0,0 @@
- `pipecat.audio.interruptions.MinWordsInterruptionStrategy` is deprecated. Use `pipecat.turns.user_start.MinWordsUserTurnStartStrategy` with `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
--- a/changelog/3205.added.md
+++ b/changelog/3205.added.md
@@ -1 +0,0 @@
- Added `RNNoiseFilter` for real-time noise suppression using RNNoise neural network via pyrnnoise library.
--- a/changelog/3225.changed.md
+++ b/changelog/3225.changed.md
@@ -1,15 +0,0 @@
- Updated `SpeechmaticsSTTService` to use new Python Voice SDK with improved VAD,
-  Smart Turn capabilities, and brings dramatic improvements to latency without
-  any impact on accuracy. Use the `turn_detection_mode` parameter to control the
-  endpointing of speech, with `TurnDetectionMode.EXTERNAL` (default),
-  `TurnDetectionMode.ADAPTIVE`, or `TurnDetectionMode.SMART_TURN`.
-  ```python
-    stt = SpeechmaticsSTTService(
-        api_key=os.getenv("SPEECHMATICS_API_KEY"),
-        params=SpeechmaticsSTTService.InputParams(
-            language=Language.EN,
-            turn_detection_mode=SpeechmaticsSTTService.TurnDetectionMode.ADAPTIVE,
-            speaker_active_format="<{speaker_id}>{text}</{speaker_id}>",
-        ),
-    )
-  ```
--- a/changelog/3225.deprecated.md
+++ b/changelog/3225.deprecated.md
@@ -1,4 +0,0 @@
- For `SpeechmaticsSTTService`, the `end_of_utterance_mode` parameter is deprecated.
-  Use the new `turn_detection_mode` parameter instead, with `TurnDetectionMode.EXTERNAL`,
-  `TurnDetectionMode.ADAPTIVE`, or `TurnDetectionMode.SMART_TURN`. The `enable_vad`
-  parameter is also deprecated and is inferred from the `turn_detection_mode`.
--- a/changelog/3233.fixed.md
+++ b/changelog/3233.fixed.md
@@ -1,2 +0,0 @@
- Improved error handling in `ElevenLabsRealtimeSTTService`
- Fixed an issue in `ElevenLabsRealtimeSTTService` causing an infinite loop that blocks the process if the websocket disconnects due to an error
--- a/changelog/3257.changed.2.md
+++ b/changelog/3257.changed.2.md
@@ -1 +0,0 @@
- `TranscriptionFrame` and `InterimTranscriptionFrame` produced by `DailyTransport` now include the transport source (i.e., the originating audio track).
--- a/changelog/3257.changed.md
+++ b/changelog/3257.changed.md
@@ -1 +0,0 @@
- `daily-python` updated to 0.23.0.
--- a/changelog/3263.deprecated.md
+++ b/changelog/3263.deprecated.md
@@ -1,15 +0,0 @@
- `OpenAILLMContext` and its associated things (context aggregators, etc.) are now deprecated in favor of the universal `LLMContext` and its associated things.
-
-  From the developer's point of view, switching to using `LLMContext` machinery will usually be a matter of going from this:
-
-  ```python
-  context = OpenAILLMContext(messages, tools)
-  context_aggregator = llm.create_context_aggregator(context)
-  ```
-
-  To this:
-
-  ```
-  context = LLMContext(messages, tools)
-  context_aggregator = LLMContextAggregatorPair(context)
-  ```
--- a/changelog/3267.added.md
+++ b/changelog/3267.added.md
@@ -1,8 +0,0 @@
- Added `GrokRealtimeLLMService` for xAI's Grok Voice Agent API with real-time voice conversations:
-
-  - Support for real-time audio streaming with WebSocket connection
-  - Built-in server-side VAD (Voice Activity Detection)
-  - Multiple voice options: Ara, Rex, Sal, Eve, Leo
-  - Built-in tools support: web_search, x_search, file_search
-  - Custom function calling with standard Pipecat tools schema
-  - Configurable audio formats (PCM at 8kHz-48kHz)
--- a/changelog/3268.added.md
+++ b/changelog/3268.added.md
@@ -1 +0,0 @@
- Added an approximation of TTFB for Ultravox.
--- a/changelog/3288.changed.md
+++ b/changelog/3288.changed.md
@@ -1,5 +0,0 @@
- Updates to Inworld TTS services:
-
-  - Improved `InworldTTSService`'s websocket implementation to better flush and
-    close context to better handle long inputs.
-  - Improved docstrings for `InworldTTSService` and `InworldHttpTTSService`.
--- a/changelog/3289.added.md
+++ b/changelog/3289.added.md
@@ -1 +0,0 @@
- Added a new `AudioContextTTSService` to the TTS service base classes. The `AudioContextWordTTSService` now inherits from `AudioContextTTSService` and `WebsocketWordTTSService`.
--- a/changelog/3291.added.md
+++ b/changelog/3291.added.md
@@ -1,4 +0,0 @@
- `LLMUserAggregator` now exposes the following events:
-   - `on_user_turn_started`: triggered when a user turn starts
-   - `on_user_turn_stopped`: triggered when a user turn ends
-   - `on_user_turn_stop_timeout`: triggered when a user turn does not stop and times out
--- a/changelog/3292.added.md
+++ b/changelog/3292.added.md
@@ -1,29 +0,0 @@
- Introducing user mute strategies. User mute strategies indicate when user input should be muted based on the current system state.
-
-  In conversational agents, user mute strategies are used to prevent user input from interrupting bot speech, tool execution, or other critical system operations.
-
-  A list of strategies can be specified; all strategies are evaluated for every frame so that each strategy can maintain its internal state. A user frame is muted if any of the configured strategies indicates it should be muted.
-
-  Available user mute strategies:
-
-  * `FirstSpeechUserMuteStrategy`
-  * `MuteUntilFirstBotCompleteUserMuteStrategy`
-  * `AlwaysUserMuteStrategy`
-  * `FunctionCallUserMuteStrategy`
-
-  User mute strategies replace the legacy `STTMuteFilter` and provide a more flexible and composable approach to muting user input.
-
-  User mute strategies are configured when setting up the `LLMContextAggregatorPair`. For example:
-
-  ```python
-  context_aggregator = LLMContextAggregatorPair(
-      context,
-      user_params=LLMUserAggregatorParams(
-          user_mute_strategies=[
-              FirstSpeechUserMuteStrategy(),
-          ]
-      ),
-  )
-  ```
-
-  In order to use user mute strategies you should update to the new universal `LLMContext` and `LLMContextAggregatorPair`.
--- a/changelog/3292.deprecated.md
+++ b/changelog/3292.deprecated.md
@@ -1 +0,0 @@
- `STTMuteFilter` is deprecated and will be removed in a future version. Use `LLMUserAggregator`'s new `user_mute_strategies` instead.
--- a/changelog/3292.fixed.md
+++ b/changelog/3292.fixed.md
@@ -1 +0,0 @@
- Fixed a bug in `STTMuteFilter` where the user was not always muted during function calls, especially when there were multiple simultaneous calls.
--- a/changelog/3297.deprecated.2.md
+++ b/changelog/3297.deprecated.2.md
@@ -1 +0,0 @@
- `FrameProcessor.interruptions_allowed` is now deprecated, use `LLMUserAggregator`'s new parameter `user_mute_strategies` instead.
--- a/changelog/3297.deprecated.md
+++ b/changelog/3297.deprecated.md
@@ -1,12 +0,0 @@
- `PipelineParams.allow_interruptions` is now deprecated, use `LLMUserAggregator`'s new parameter `turn_start_strategies` instead. For example, to disable interruptions but still get user turns you can do:
-
-  ```python
-  context_aggregator = LLMContextAggregatorPair(
-      context,
-      user_params=LLMUserAggregatorParams(
-          user_turn_strategies=UserTurnStrategies(
-              start=[TranscriptionUserTurnStartStrategy(enable_interruptions=False)],
-          ),
-      ),
-  )
-  ```
--- a/changelog/3300.added.md
+++ b/changelog/3300.added.md
@@ -1 +0,0 @@
- Added `use_ssl` parameter to `NvidiaSTTService`, `NvidiaSegmentedSTTService` and `NvidiaTTSService`.
--- a/changelog/3314.changed.md
+++ b/changelog/3314.changed.md
@@ -1 +0,0 @@
- Updated `DeepgramSTTService` to push user started/stopped speaking and interruption frames when `vad_enabled` is set to true. This centralizes the frames into the service, removing the need to have your application code handle Deepgram's events and push these frames.
--- a/changelog/3316.added.md
+++ b/changelog/3316.added.md
@@ -1 +0,0 @@
- Added `enable_interruptions` constructor argument to all user turn strategies. This tells the `LLMUserAggregator` to push or not push an `InterruptionFrame`.
--- a/changelog/3316.other.md
+++ b/changelog/3316.other.md
@@ -1 +0,0 @@
- Added `52-live-transcription.py` foundational example demonstrating live transcription and translation from English to Spanish. In this example, the bot is not interruptible: as the user continues speaking, English transcriptions are queued, and the bot continuously translates and speaks each queued sentence in Spanish without being interrupted by new user speech.
--- a/env.example
+++ b/env.example
@@ -97,7 +97,8 @@ INWORLD_API_KEY=...
 KRISP_MODEL_PATH=...

 # Krisp Viva
-KRISP_VIVA_MODEL_PATH=...
+KRISP_VIVA_FILTER_MODEL_PATH=...
+KRISP_VIVA_TURN_MODEL_PATH=...

 # LiveKit
 LIVEKIT_API_KEY=...
--- a/examples/foundational/01-say-one-thing-piper.py
+++ b/examples/foundational/01-say-one-thing-piper.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/01-say-one-thing-rime.py
+++ b/examples/foundational/01-say-one-thing-rime.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/01-say-one-thing.py
+++ b/examples/foundational/01-say-one-thing.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/01a-local-audio.py
+++ b/examples/foundational/01a-local-audio.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/01b-livekit-audio.py
+++ b/examples/foundational/01b-livekit-audio.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/01c-nvidia-riva-tts.py
+++ b/examples/foundational/01c-nvidia-riva-tts.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/02-llm-say-one-thing.py
+++ b/examples/foundational/02-llm-say-one-thing.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/03-still-frame.py
+++ b/examples/foundational/03-still-frame.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/03a-local-still-frame.py
+++ b/examples/foundational/03a-local-still-frame.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/03b-still-frame-imagen.py
+++ b/examples/foundational/03b-still-frame-imagen.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/04-transports-small-webrtc.py
+++ b/examples/foundational/04-transports-small-webrtc.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -85,7 +85,7 @@ async def run_example(webrtc_connection: SmallWebRTCConnection):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -98,11 +98,11 @@ async def run_example(webrtc_connection: SmallWebRTCConnection):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/04a-transports-daily.py
+++ b/examples/foundational/04a-transports-daily.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -68,7 +68,7 @@ async def main():
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -82,11 +82,11 @@ async def main():
        pipeline = Pipeline(
            [
                transport.input(),  # Transport user input
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/04b-transports-livekit.py
+++ b/examples/foundational/04b-transports-livekit.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def main():
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def main():
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/05-sync-speech-and-image.py
+++ b/examples/foundational/05-sync-speech-and-image.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/05a-local-sync-speech-and-image.py
+++ b/examples/foundational/05a-local-sync-speech-and-image.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
--- a/examples/foundational/06-listen-and-respond.py
+++ b/examples/foundational/06-listen-and-respond.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -106,7 +106,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -119,12 +119,12 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),
            stt,
-            context_aggregator.user(),
+            user_aggregator,
            llm,
            tts,
            ml,
            transport.output(),
-            context_aggregator.assistant(),
+            assistant_aggregator,
        ]
    )

--- a/examples/foundational/06a-image-sync.py
+++ b/examples/foundational/06a-image-sync.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -120,7 +120,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -138,12 +138,12 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),
            stt,
-            context_aggregator.user(),
+            user_aggregator,
            llm,
            tts,
            image_sync_aggregator,
            transport.output(),
-            context_aggregator.assistant(),
+            assistant_aggregator,
        ]
    )

--- a/examples/foundational/07-interruptible-cartesia-http.py
+++ b/examples/foundational/07-interruptible-cartesia-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -77,7 +77,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -90,11 +90,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07-interruptible.py
+++ b/examples/foundational/07-interruptible.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -76,7 +76,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -89,11 +89,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07a-interruptible-speechmatics-vad.py
+++ b/examples/foundational/07a-interruptible-speechmatics-vad.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -131,7 +131,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(user_turn_strategies=ExternalUserTurnStrategies()),
        )
@@ -140,11 +140,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07a-interruptible-speechmatics.py
+++ b/examples/foundational/07a-interruptible-speechmatics.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -117,7 +117,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -132,11 +132,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,  # STT
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07a-non-interruptible.py
+++ b/examples/foundational/07a-non-interruptible.py
@@ -0,0 +1,217 @@
+#
+# Copyright (c) 2024-2026, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""
+This example demonstrates how to dynamically toggle interruptions while still
+transcribing user speech. Every 5 seconds, the bot toggles between:
+- Interruptible mode: user speech will interrupt the bot
+- Non-interruptible mode: user speech is transcribed but won't interrupt
+
+This is useful when you want to capture what the user says during bot speech
+without interrupting the bot's response, and then re-enable interruptions later.
+
+The key mechanism is a custom frame (`EnableInterruptionsFrame`) that is queued
+into the pipeline. A custom `DynamicVADUserTurnStartStrategy` subclasses
+`VADUserTurnStartStrategy` and listens for this frame to update its
+`enable_interruptions` setting at runtime.
+
+In both modes:
+- Voice Activity Detection (VAD) continues working
+- Speech-to-text transcription continues
+- User turns are aggregated into context
+
+Watch the logs to see when interruptions are enabled/disabled, then try speaking
+while the bot talks to observe the different behaviors.
+"""
+
+import asyncio
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+from loguru import logger
+
+from pipecat.audio.turn.smart_turn.local_smart_turn_v3 import LocalSmartTurnAnalyzerV3
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.audio.vad.vad_analyzer import VADParams
+from pipecat.frames.frames import Frame, LLMRunFrame, SystemFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams,
+)
+from pipecat.runner.types import RunnerArguments
+from pipecat.runner.utils import create_transport
+from pipecat.services.cartesia.tts import CartesiaTTSService
+from pipecat.services.deepgram.stt import DeepgramSTTService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transports.base_transport import BaseTransport, TransportParams
+from pipecat.transports.daily.transport import DailyParams
+from pipecat.transports.websocket.fastapi import FastAPIWebsocketParams
+from pipecat.turns.user_start import VADUserTurnStartStrategy
+from pipecat.turns.user_stop import TurnAnalyzerUserTurnStopStrategy
+from pipecat.turns.user_turn_strategies import UserTurnStrategies
+
+
+@dataclass
+class EnableInterruptionsFrame(SystemFrame):
+    """A custom frame to dynamically enable or disable interruptions.
+
+    Queue this frame into the pipeline to change the interruption behavior
+    of DynamicVADUserTurnStartStrategy at runtime.
+    """
+
+    enable_interruptions: bool
+
+
+class DynamicVADUserTurnStartStrategy(VADUserTurnStartStrategy):
+    """A VAD-based user turn start strategy with dynamic interruption control.
+
+    This strategy extends VADUserTurnStartStrategy to listen for
+    EnableInterruptionsFrame, allowing the enable_interruptions setting
+    to be changed at runtime via the pipeline.
+
+    Example:
+        # Create strategy with interruptions initially disabled
+        strategy = DynamicVADUserTurnStartStrategy(enable_interruptions=False)
+
+        # Later, toggle interruptions by queuing a frame
+        await task.queue_frame(EnableInterruptionsFrame(enable_interruptions=True))
+    """
+
+    async def process_frame(self, frame: Frame):
+        """Process frames, updating enable_interruptions when our custom frame arrives."""
+        if isinstance(frame, EnableInterruptionsFrame):
+            self._enable_interruptions = frame.enable_interruptions
+            logger.info(f"Interruptions {'ENABLED' if frame.enable_interruptions else 'DISABLED'}")
+
+        await super().process_frame(frame)
+
+
+load_dotenv(override=True)
+
+# We store functions so objects (e.g. SileroVADAnalyzer) don't get
+# instantiated. The function will be called when the desired transport gets
+# selected.
+transport_params = {
+    "daily": lambda: DailyParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+    "twilio": lambda: FastAPIWebsocketParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+    "webrtc": lambda: TransportParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+}
+
+
+async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
+    logger.info(f"Starting bot")
+
+    stt = DeepgramSTTService(api_key=os.getenv("DEEPGRAM_API_KEY"))
+
+    tts = CartesiaTTSService(
+        api_key=os.getenv("CARTESIA_API_KEY"),
+        voice_id="71a7ad14-091c-4e8e-a314-022ece01c121",  # British Reading Lady
+    )
+
+    llm = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY"))
+
+    messages = [
+        {
+            "role": "system",
+            "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate toggling interruptible behavior. Give longer responses so the user can test speaking while you talk. Sometimes your speech can be interrupted, sometimes it cannot. The system will toggle every 5 seconds. Your output will be spoken aloud, so avoid special characters that can't easily be spoken, such as emojis or bullet points.",
+        },
+    ]
+
+    context = LLMContext(messages)
+
+    # Create a dynamic VAD strategy that can be toggled at runtime via frames.
+    # This strategy extends VADUserTurnStartStrategy but listens for
+    # EnableInterruptionsFrame to change enable_interruptions dynamically.
+    dynamic_strategy = DynamicVADUserTurnStartStrategy(enable_interruptions=False)
+
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(
+            user_turn_strategies=UserTurnStrategies(
+                start=[dynamic_strategy],
+                stop=[TurnAnalyzerUserTurnStopStrategy(turn_analyzer=LocalSmartTurnAnalyzerV3())],
+            ),
+        ),
+    )
+
+    pipeline = Pipeline(
+        [
+            transport.input(),  # Transport user input
+            stt,
+            user_aggregator,  # User responses
+            llm,  # LLM
+            tts,  # TTS
+            transport.output(),  # Transport bot output
+            assistant_aggregator,  # Assistant spoken responses
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(
+            enable_metrics=True,
+            enable_usage_metrics=True,
+        ),
+        idle_timeout_secs=runner_args.pipeline_idle_timeout_secs,
+    )
+
+    @transport.event_handler("on_client_connected")
+    async def on_client_connected(transport, client):
+        logger.info(f"Client connected")
+
+        # Kick off the conversation.
+        messages.append({"role": "system", "content": "Please introduce yourself to the user."})
+        await task.queue_frames([LLMRunFrame()])
+
+        # Toggle interruptions every 5 seconds by queuing EnableInterruptionsFrame.
+        # This is the idiomatic Pipecat way to control behavior via frames.
+        interruptions_enabled = False
+        for _ in range(10):  # Toggle 10 times (50 seconds total)
+            await asyncio.sleep(5)
+            interruptions_enabled = not interruptions_enabled
+
+            # Queue a frame to toggle interruptions - the strategy will pick it up
+            await task.queue_frame(
+                EnableInterruptionsFrame(enable_interruptions=interruptions_enabled)
+            )
+
+    @transport.event_handler("on_client_disconnected")
+    async def on_client_disconnected(transport, client):
+        logger.info(f"Client disconnected")
+        await task.cancel()
+
+    runner = PipelineRunner(handle_sigint=runner_args.handle_sigint)
+
+    await runner.run(task)
+
+
+async def bot(runner_args: RunnerArguments):
+    """Main bot entry point compatible with Pipecat Cloud."""
+    transport = await create_transport(runner_args, transport_params)
+    await run_bot(transport, runner_args)
+
+
+if __name__ == "__main__":
+    from pipecat.runner.run import main
+
+    main()
--- a/examples/foundational/07aa-interruptible-soniox.py
+++ b/examples/foundational/07aa-interruptible-soniox.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -76,7 +76,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -89,11 +89,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )
    task = PipelineTask(
--- a/examples/foundational/07ab-interruptible-inworld-http.py
+++ b/examples/foundational/07ab-interruptible-inworld-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -82,7 +82,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -100,11 +100,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
                transport.input(),
                rtvi,
                stt,
-                context_aggregator.user(),
+                user_aggregator,
                llm,
                tts,
                transport.output(),
-                context_aggregator.assistant(),
+                assistant_aggregator,
            ]
        )

--- a/examples/foundational/07ab-interruptible-inworld.py
+++ b/examples/foundational/07ab-interruptible-inworld.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -79,7 +79,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -95,11 +95,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            transport.input(),
            rtvi,
            stt,
-            context_aggregator.user(),
+            user_aggregator,
            llm,
            tts,
            transport.output(),
-            context_aggregator.assistant(),
+            assistant_aggregator,
        ]
    )

--- a/examples/foundational/07ac-interruptible-asyncai-http.py
+++ b/examples/foundational/07ac-interruptible-asyncai-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -82,7 +82,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -97,11 +97,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07ac-interruptible-asyncai.py
+++ b/examples/foundational/07ac-interruptible-asyncai.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07ad-interruptible-aicoustics.py
+++ b/examples/foundational/07ad-interruptible-aicoustics.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -105,7 +105,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -118,12 +118,12 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
            audiobuffer,  # write audio data to a file
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07ae-interruptible-hume.py
+++ b/examples/foundational/07ae-interruptible-hume.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -81,7 +81,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -97,11 +97,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            transport.input(),  # Transport user input
            rtvi,
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS (HumeTTSService with word timestamps)
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07af-interruptible-gradium.py
+++ b/examples/foundational/07af-interruptible-gradium.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -76,7 +76,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -89,11 +89,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07b-interruptible-langchain.py
+++ b/examples/foundational/07b-interruptible-langchain.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -103,7 +103,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    lc = LangchainProcessor(history_chain)

    context = LLMContext()
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -116,11 +116,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            lc,  # Langchain
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07c-interruptible-deepgram-flux.py
+++ b/examples/foundational/07c-interruptible-deepgram-flux.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -71,7 +71,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(user_turn_strategies=ExternalUserTurnStrategies()),
    )
@@ -80,11 +80,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07c-interruptible-deepgram-http.py
+++ b/examples/foundational/07c-interruptible-deepgram-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -81,7 +81,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -96,11 +96,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,  # STT
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07c-interruptible-deepgram-sagemaker.py
+++ b/examples/foundational/07c-interruptible-deepgram-sagemaker.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -86,7 +86,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -99,11 +99,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07c-interruptible-deepgram-vad.py
+++ b/examples/foundational/07c-interruptible-deepgram-vad.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -72,7 +72,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(user_turn_strategies=ExternalUserTurnStrategies()),
    )
@@ -81,11 +81,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07c-interruptible-deepgram.py
+++ b/examples/foundational/07c-interruptible-deepgram.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -75,7 +75,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -88,11 +88,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07d-interruptible-elevenlabs-http.py
+++ b/examples/foundational/07d-interruptible-elevenlabs-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -85,7 +85,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -100,11 +100,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07d-interruptible-elevenlabs.py
+++ b/examples/foundational/07d-interruptible-elevenlabs.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07e-interruptible-playht-http.py
+++ b/examples/foundational/07e-interruptible-playht-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07e-interruptible-playht.py
+++ b/examples/foundational/07e-interruptible-playht.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -80,7 +80,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -93,11 +93,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07f-interruptible-azure-http.py
+++ b/examples/foundational/07f-interruptible-azure-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -84,7 +84,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -97,11 +97,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07f-interruptible-azure.py
+++ b/examples/foundational/07f-interruptible-azure.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -84,7 +84,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -97,11 +97,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07g-interruptible-openai.py
+++ b/examples/foundational/07g-interruptible-openai.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07h-interruptible-openpipe.py
+++ b/examples/foundational/07h-interruptible-openpipe.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -83,7 +83,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -96,11 +96,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07i-interruptible-xtts.py
+++ b/examples/foundational/07i-interruptible-xtts.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -81,7 +81,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -96,11 +96,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07j-interruptible-gladia-vad.py
+++ b/examples/foundational/07j-interruptible-gladia-vad.py
@@ -0,0 +1,140 @@
+#
+# Copyright (c) 2024-2026, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+
+import os
+
+from dotenv import load_dotenv
+from loguru import logger
+
+from pipecat.audio.vad.silero import SileroVADAnalyzer
+from pipecat.audio.vad.vad_analyzer import VADParams
+from pipecat.frames.frames import LLMRunFrame
+from pipecat.pipeline.pipeline import Pipeline
+from pipecat.pipeline.runner import PipelineRunner
+from pipecat.pipeline.task import PipelineParams, PipelineTask
+from pipecat.processors.aggregators.llm_context import LLMContext
+from pipecat.processors.aggregators.llm_response_universal import (
+    LLMContextAggregatorPair,
+    LLMUserAggregatorParams,
+)
+from pipecat.runner.types import RunnerArguments
+from pipecat.runner.utils import create_transport
+from pipecat.services.cartesia.tts import CartesiaTTSService
+from pipecat.services.gladia.config import GladiaInputParams, LanguageConfig
+from pipecat.services.gladia.stt import GladiaSTTService
+from pipecat.services.openai.llm import OpenAILLMService
+from pipecat.transcriptions.language import Language
+from pipecat.transports.base_transport import BaseTransport, TransportParams
+from pipecat.transports.daily.transport import DailyParams
+from pipecat.transports.websocket.fastapi import FastAPIWebsocketParams
+from pipecat.turns.user_turn_strategies import ExternalUserTurnStrategies
+
+load_dotenv(override=True)
+
+# We store functions so objects (e.g. SileroVADAnalyzer) don't get
+# instantiated. The function will be called when the desired transport gets
+# selected.
+transport_params = {
+    "daily": lambda: DailyParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+    "twilio": lambda: FastAPIWebsocketParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+    "webrtc": lambda: TransportParams(
+        audio_in_enabled=True,
+        audio_out_enabled=True,
+        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
+    ),
+}
+
+
+async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
+    logger.info(f"Starting bot")
+
+    stt = GladiaSTTService(
+        api_key=os.getenv("GLADIA_API_KEY", ""),
+        region=os.getenv("GLADIA_REGION"),
+        params=GladiaInputParams(
+            language_config=LanguageConfig(
+                languages=[Language.EN],
+            ),
+            enable_vad=True,
+        ),
+    )
+
+    tts = CartesiaTTSService(
+        api_key=os.getenv("CARTESIA_API_KEY", ""),
+        voice_id="71a7ad14-091c-4e8e-a314-022ece01c121",  # British Reading Lady
+    )
+
+    llm = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY", ""))
+
+    messages = [
+        {
+            "role": "system",
+            "content": f"You are a helpful LLM. Your goal is to demonstrate your capabilities in a succinct way. Your output will be spoken aloud, so avoid special characters that can't easily be spoken, such as emojis or bullet points. Respond to what the user said in a creative and helpful way.",
+        },
+    ]
+
+    context = LLMContext(messages)
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
+        context,
+        user_params=LLMUserAggregatorParams(user_turn_strategies=ExternalUserTurnStrategies()),
+    )
+
+    pipeline = Pipeline(
+        [
+            transport.input(),  # Transport user input
+            stt,  # STT
+            user_aggregator,  # User responses
+            llm,  # LLM
+            tts,  # TTS
+            transport.output(),  # Transport bot output
+            assistant_aggregator,  # Assistant spoken responses
+        ]
+    )
+
+    task = PipelineTask(
+        pipeline,
+        params=PipelineParams(
+            enable_metrics=True,
+            enable_usage_metrics=True,
+        ),
+        idle_timeout_secs=runner_args.pipeline_idle_timeout_secs,
+    )
+
+    @transport.event_handler("on_client_connected")
+    async def on_client_connected(transport, client):
+        logger.info(f"Client connected")
+        # Kick off the conversation.
+        messages.append({"role": "system", "content": "Please introduce yourself to the user."})
+        await task.queue_frames([LLMRunFrame()])
+
+    @transport.event_handler("on_client_disconnected")
+    async def on_client_disconnected(transport, client):
+        logger.info(f"Client disconnected")
+        await task.cancel()
+
+    runner = PipelineRunner(handle_sigint=runner_args.handle_sigint)
+    await runner.run(task)
+
+
+async def bot(runner_args: RunnerArguments):
+    """Main bot entry point compatible with Pipecat Cloud."""
+    transport = await create_transport(runner_args, transport_params)
+    await run_bot(transport, runner_args)
+
+
+if __name__ == "__main__":
+    from pipecat.runner.run import main
+
+    main()
--- a/examples/foundational/07j-interruptible-gladia.py
+++ b/examples/foundational/07j-interruptible-gladia.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -87,7 +87,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -100,11 +100,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07k-interruptible-lmnt.py
+++ b/examples/foundational/07k-interruptible-lmnt.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -75,7 +75,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -88,11 +88,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User respones
+            user_aggregator,  # User respones
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07l-interruptible-groq.py
+++ b/examples/foundational/07l-interruptible-groq.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -76,7 +76,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -89,11 +89,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07m-interruptible-aws-strands.py
+++ b/examples/foundational/07m-interruptible-aws-strands.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -120,7 +120,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):

    # Setup context aggregators for message handling
    context = LLMContext()
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -133,11 +133,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # Speech-to-text
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # Strands Agents processor
            tts,  # Text-to-speech
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07m-interruptible-aws.py
+++ b/examples/foundational/07m-interruptible-aws.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -80,7 +80,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -93,11 +93,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07n-interruptible-gemini-image.py
+++ b/examples/foundational/07n-interruptible-gemini-image.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -102,7 +102,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -115,11 +115,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # Gemini TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07n-interruptible-gemini.py
+++ b/examples/foundational/07n-interruptible-gemini.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -107,7 +107,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -120,11 +120,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # Gemini TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07n-interruptible-google-http.py
+++ b/examples/foundational/07n-interruptible-google-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -90,7 +90,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -103,11 +103,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User respones
+            user_aggregator,  # User respones
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07n-interruptible-google.py
+++ b/examples/foundational/07n-interruptible-google.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -90,7 +90,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -103,11 +103,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User respones
+            user_aggregator,  # User respones
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07o-interruptible-assemblyai.py
+++ b/examples/foundational/07o-interruptible-assemblyai.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -80,7 +80,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -93,11 +93,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07p-interruptible-krisp-viva.py
+++ b/examples/foundational/07p-interruptible-krisp-viva.py
@@ -1,9 +1,26 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #

+"""Interruptible bot with Krisp VIVA noise filtering and turn detection.
+
+This example demonstrates a conversational bot with:
+- Krisp VIVA noise reduction on incoming audio
+- Krisp VIVA Turn detection for natural interruptions
+- Voice activity detection (VAD)
+
+Required environment variables:
+- KRISP_VIVA_FILTER_MODEL_PATH: Path to the Krisp noise filter model file (.kef)
+- KRISP_VIVA_TURN_MODEL_PATH: Path to the Krisp turn detection model file (.kef)
+- DEEPGRAM_API_KEY: Deepgram API key for STT/TTS
+- OPENAI_API_KEY: OpenAI API key for LLM
+
+Optional environment variables:
+- KRISP_NOISE_SUPPRESSION_LEVEL: Noise suppression level 0-100 (default: 100)
+  Higher values = more aggressive noise reduction
+"""

 import os

@@ -11,7 +28,7 @@ from dotenv import load_dotenv
 from loguru import logger

 from pipecat.audio.filters.krisp_viva_filter import KrispVivaFilter
-from pipecat.audio.turn.smart_turn.local_smart_turn_v3 import LocalSmartTurnAnalyzerV3
+from pipecat.audio.turn.krisp_viva_turn import KrispTurnParams, KrispVivaTurn
 from pipecat.audio.vad.silero import SileroVADAnalyzer
 from pipecat.audio.vad.vad_analyzer import VADParams
 from pipecat.frames.frames import LLMRunFrame
@@ -78,11 +95,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
-                stop=[TurnAnalyzerUserTurnStopStrategy(turn_analyzer=LocalSmartTurnAnalyzerV3())]
+                stop=[TurnAnalyzerUserTurnStopStrategy(turn_analyzer=KrispVivaTurn())]
            ),
        ),
    )
@@ -91,11 +108,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07p-interruptible-krisp.py
+++ b/examples/foundational/07p-interruptible-krisp.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07q-interruptible-rime-http.py
+++ b/examples/foundational/07q-interruptible-rime-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -83,7 +83,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -98,11 +98,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07q-interruptible-rime.py
+++ b/examples/foundational/07q-interruptible-rime.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -77,7 +77,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -90,11 +90,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07r-interruptible-nvidia.py
+++ b/examples/foundational/07r-interruptible-nvidia.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -76,7 +76,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -89,11 +89,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07s-interruptible-google-audio-in.py
+++ b/examples/foundational/07s-interruptible-google-audio-in.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -249,7 +249,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -257,7 +257,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            ),
        ),
    )
-    audio_collector = UserAudioCollector(context, context_aggregator.user())
+    audio_collector = UserAudioCollector(context, user_aggregator)
    pull_transcript_out_of_llm_output = TranscriptExtractor(context)
    fixup_context_messages = TranscriptionContextFixup(context)

@@ -265,12 +265,12 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            audio_collector,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            pull_transcript_out_of_llm_output,
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
            fixup_context_messages,
        ]
    )
--- a/examples/foundational/07t-interruptible-fish.py
+++ b/examples/foundational/07t-interruptible-fish.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -78,7 +78,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -91,11 +91,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07v-interruptible-neuphonic-http.py
+++ b/examples/foundational/07v-interruptible-neuphonic-http.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -82,7 +82,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        ]

        context = LLMContext(messages)
-        context_aggregator = LLMContextAggregatorPair(
+        user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
            context,
            user_params=LLMUserAggregatorParams(
                user_turn_strategies=UserTurnStrategies(
@@ -97,11 +97,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
            [
                transport.input(),  # Transport user input
                stt,
-                context_aggregator.user(),  # User responses
+                user_aggregator,  # User responses
                llm,  # LLM
                tts,  # TTS
                transport.output(),  # Transport bot output
-                context_aggregator.assistant(),  # Assistant spoken responses
+                assistant_aggregator,  # Assistant spoken responses
            ]
        )

--- a/examples/foundational/07v-interruptible-neuphonic.py
+++ b/examples/foundational/07v-interruptible-neuphonic.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -77,7 +77,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -90,11 +90,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/examples/foundational/07w-interruptible-fal.py
+++ b/examples/foundational/07w-interruptible-fal.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -80,7 +80,7 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -93,11 +93,11 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
        [
            transport.input(),  # Transport user input
            stt,  # STT
-            context_aggregator.user(),  # User responses
+            user_aggregator,  # User responses
            llm,  # LLM
            tts,  # TTS
            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # Assistant spoken responses
+            assistant_aggregator,  # Assistant spoken responses
        ]
    )

--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				- ⚠️ `TransportParams.turn_analyzer` is deprecated and might result in unexpected behavior, use `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
				`@@ -1 +0,0 @@`
				- `FrameProcessor.interruption_strategies` is deprecated, use `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
				`@@ -1 +0,0 @@`
				- `EmulateUserStartedSpeakingFrame` and `EmulateUserStoppedSpeakingFrame` frames are deprecated.
				`@@ -1 +0,0 @@`
				- Deprecated the `emulated` field in the `UserStartedSpeakingFrame` and `UserStoppedSpeakingFrame` frames.
				`@@ -1 +0,0 @@`
				- The `LLMUserAggregatorParams` and `LLMAssistantAggregatorParams` classes in `pipecat.processors.aggregators.llm_response` are now deprecated. Use the new universal `LLMContext` and `LLMContextAggregatorPair` instead.
				`@@ -1 +0,0 @@`
				- `pipecat.audio.interruptions.MinWordsInterruptionStrategy` is deprecated. Use `pipecat.turns.user_start.MinWordsUserTurnStartStrategy` with `LLMUserAggregator`'s new `turn_start_strategies` parameter instead.
				`@@ -1 +0,0 @@`
				- Added `RNNoiseFilter` for real-time noise suppression using RNNoise neural network via pyrnnoise library.
				`@@ -1 +0,0 @@`
				- `TranscriptionFrame` and `InterimTranscriptionFrame` produced by `DailyTransport` now include the transport source (i.e., the originating audio track).
				`@@ -1 +0,0 @@`
				`- Added an approximation of TTFB for Ultravox.`
				`@@ -1 +0,0 @@`
				- Added a new `AudioContextTTSService` to the TTS service base classes. The `AudioContextWordTTSService` now inherits from `AudioContextTTSService` and `WebsocketWordTTSService`.