Merge pull request #3440 from pipecat-ai/changelog-0.0.99

Release 0.0.99 - Changelog Update
update cosmetic changelog updates for 0.0.99
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 · 2026-01-13 16:45:44 -08:00 · 2026-01-13 19:43:50 -05:00
652 changed files with 10468 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/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/examples/foundational/07x-interruptible-local.py
+++ b/examples/foundational/07x-interruptible-local.py
@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2024–2025, Daily
+# Copyright (c) 2024-2026, Daily
 #
 # SPDX-License-Identifier: BSD 2-Clause License
 #
@@ -62,7 +62,7 @@ async def main():
    ]

    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(
+    user_aggregator, assistant_aggregator = LLMContextAggregatorPair(
        context,
        user_params=LLMUserAggregatorParams(
            user_turn_strategies=UserTurnStrategies(
@@ -75,11 +75,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/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`.