claude thinking model support

fix: AWSTranscribeSTTService always set to us-east-1

CHANGELOG.md

@@ -5,10 +5,33 @@ All notable changes to **Pipecat** will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Changed
+
+- Updated `AICFilter` to use Quail STT as the default model
+  (`AICModelType.QUAIL_STT`). Quail STT is optimized for human-to-machine
+  interaction (e.g., voice agents, speech-to-text) and operates at a native
+  sample rate of 16 kHz with fixed enhancement parameters.
+
+### Deprecated
+
+- The `noise_gate_enable` parameter in `AICFilter` is deprecated and no longer
+  has any effect. Noise gating is now handled automatically by the AIC VAD
+  system. Use `AICFilter.create_vad_analyzer()` for VAD functionality instead.
+
+### Fixed
+
+- Fixed an issue in `AWSTranscribeSTTService` where the `region` arg was
+  always set to `us-east-1` when providing an AWS_REGION env var.
+
 ## [0.0.96] - 2025-11-26 🦃 "Happy Thanksgiving!" 🦃
 
 ### Added
 
+- Added `AWSBedrockAgentCoreProcessor` to support invoking an AgentCore-hosted
+  agent in a Pipecat pipeline.
+
 - Enhanced error handling across the framework:
 
   - Added `on_error` callback to `FrameProcessor` for centralized error
@@ -280,7 +303,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Fixed an issue in `AWSBedrockLLMService` where the `aws_region` arg was
-  always set to `us-east-1`.
+  always set to `us-east-1` when providing an AWS_REGION env var.
 
 - Fixed an issue with `DeepgramFluxSTTService` where it sometimes failed to reconnect.
 

examples/foundational/14a-function-calling-anthropic.py

@@ -82,6 +82,13 @@ async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
     llm = AnthropicLLMService(
         api_key=os.getenv("ANTHROPIC_API_KEY"),
         model="claude-3-7-sonnet-latest",
+        wait_for_all=True,
+        params=AnthropicLLMService.InputParams(
+            max_tokens=16000,
+            extra={
+                "thinking": {"type": "enabled", "budget_tokens": 10000},
+            },
+        ),
     )
     llm.register_function("get_weather", get_weather)
     llm.register_function("get_restaurant_recommendation", fetch_restaurant_recommendation)

pyproject.toml

@@ -45,7 +45,7 @@ Source = "https://github.com/pipecat-ai/pipecat"
 Website = "https://pipecat.ai"
 
 [project.optional-dependencies]
-aic = [ "aic-sdk~=1.1.0" ]
+aic = [ "aic-sdk~=1.2.0" ]
 anthropic = [ "anthropic~=0.49.0" ]
 assemblyai = [ "pipecat-ai[websockets-base]" ]
 asyncai = [ "pipecat-ai[websockets-base]" ]

src/pipecat/audio/filters/aic_filter.py

@@ -39,7 +39,7 @@ class AICFilter(BaseAudioFilter):
         self,
         *,
         license_key: str = "",
-        model_type: AICModelType = AICModelType.QUAIL_L,
+        model_type: AICModelType = AICModelType.QUAIL_STT,
         enhancement_level: Optional[float] = 1.0,
         voice_gain: Optional[float] = 1.0,
         noise_gate_enable: Optional[bool] = True,
@@ -52,12 +52,27 @@ class AICFilter(BaseAudioFilter):
             enhancement_level: Optional overall enhancement strength (0.0..1.0).
             voice_gain: Optional linear gain applied to detected speech (0.0..4.0).
             noise_gate_enable: Optional enable/disable noise gate (default: True).
+
+                .. deprecated:: 1.3.0
+                    The `noise_gate_enable` parameter is deprecated and no longer has any effect.
+                    It will be removed in a future version.
         """
         self._license_key = license_key
         self._model_type = model_type
 
         self._enhancement_level = enhancement_level
         self._voice_gain = voice_gain
+        if noise_gate_enable is not None:
+            import warnings
+
+            with warnings.catch_warnings():
+                warnings.simplefilter("always")
+                warnings.warn(
+                    "Parameter `noise_gate_enable` is deprecated and no longer has any effect. "
+                    "It will be removed in a future version. Use AIC VAD instead (create_vad_analyzer()).",
+                    DeprecationWarning,
+                )
+
         self._noise_gate_enable = noise_gate_enable
 
         self._enabled = True
@@ -149,10 +164,6 @@ class AICFilter(BaseAudioFilter):
                 )
             if self._voice_gain is not None:
                 self._aic.set_parameter(AICParameter.VOICE_GAIN, float(self._voice_gain))
-            if self._noise_gate_enable is not None:
-                self._aic.set_parameter(
-                    AICParameter.NOISE_GATE_ENABLE, 1.0 if bool(self._noise_gate_enable) else 0.0
-                )
 
             self._aic_ready = True
 

src/pipecat/frames/frames.py

@@ -327,19 +327,23 @@ class TextFrame(DataFrame):
 
     Parameters:
         text: The text content.
-        skip_tts: Whether this text should skip TTS processing.
     """
 
     text: str
-    skip_tts: bool = field(default=False, kw_only=True)
+    skip_tts: bool = field(init=False)
     # Whether any necessary inter-frame (leading/trailing) spaces are already
     # included in the text.
+    # NOTE: Ideally this would be available at init time with a default value,
+    # but that would impact how subclasses can be initialized (it would require
+    # mandatory fields of theirs to have defaults to preserve
+    # non-default-before-default argument order)
     includes_inter_frame_spaces: bool = field(init=False)
     # Whether this text frame should be appended to the LLM context.
     append_to_context: bool = field(init=False)
 
     def __post_init__(self):
         super().__post_init__()
+        self.skip_tts = False
         self.includes_inter_frame_spaces = False
         self.append_to_context = True
 
@@ -559,6 +563,33 @@ class LLMContextFrame(Frame):
     context: "LLMContext"
 
 
+@dataclass
+class LLMThinkingTextFrame(DataFrame):
+    """Reasoning frame generated by LLM services."""
+
+    thinking: str
+
+    def __post_init__(self):
+        super().__post_init__()
+        # LLM services send text frames with all necessary spaces included
+        self.includes_inter_frame_spaces = True
+
+    def __str__(self):
+        pts = format_pts(self.pts)
+        return f"{self.name}(pts: {pts}, thinking: {self.thinking})"
+
+
+@dataclass
+class LLMThinkingSignatureFrame(DataFrame):
+    """Reasoning signature frame generated by LLM services."""
+
+    signature: str
+
+    def __str__(self):
+        pts = format_pts(self.pts)
+        return f"{self.name}(pts: {pts}, signature: {self.signature})"
+
+
 @dataclass
 class LLMMessagesFrame(DataFrame):
     """Frame containing LLM messages for chat completion.
@@ -1626,23 +1657,24 @@ class LLMFullResponseStartFrame(ControlFrame):
 
     Used to indicate the beginning of an LLM response. Followed by one or
     more TextFrames and a final LLMFullResponseEndFrame.
-
-    Parameters:
-        skip_tts: Whether LLM output should skip TTS processing.
     """
 
-    skip_tts: bool = field(default=False, kw_only=True)
+    skip_tts: bool = field(init=False)
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.skip_tts = False
 
 
 @dataclass
 class LLMFullResponseEndFrame(ControlFrame):
-    """Frame indicating the end of an LLM response.
+    """Frame indicating the end of an LLM response."""
 
-    Parameters:
-        skip_tts: Whether LLM output should skip TTS processing.
-    """
+    skip_tts: bool = field(init=False)
 
-    skip_tts: bool = field(default=False, kw_only=True)
+    def __post_init__(self):
+        super().__post_init__()
+        self.skip_tts = False
 
 
 @dataclass

src/pipecat/processors/aggregators/llm_response_universal.py

@@ -47,6 +47,8 @@ from pipecat.frames.frames import (
     LLMRunFrame,
     LLMSetToolChoiceFrame,
     LLMSetToolsFrame,
+    LLMThinkingSignatureFrame,
+    LLMThinkingTextFrame,
     SpeechControlParamsFrame,
     StartFrame,
     TextFrame,
@@ -591,6 +593,7 @@ class LLMAssistantAggregator(LLMContextAggregator):
         self._started = 0
         self._function_calls_in_progress: Dict[str, Optional[FunctionCallInProgressFrame]] = {}
         self._context_updated_tasks: Set[asyncio.Task] = set()
+        self._thinking: List[TextPartForConcatenation] = []
 
     @property
     def has_function_calls_in_progress(self) -> bool:
@@ -601,6 +604,11 @@ class LLMAssistantAggregator(LLMContextAggregator):
         """
         return bool(self._function_calls_in_progress)
 
+    async def reset(self):
+        """Reset the aggregation state."""
+        await super().reset()
+        self._thinking = []
+
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         """Process frames for assistant response aggregation and function call management.
 
@@ -619,6 +627,10 @@ class LLMAssistantAggregator(LLMContextAggregator):
             await self._handle_llm_end(frame)
         elif isinstance(frame, TextFrame):
             await self._handle_text(frame)
+        elif isinstance(frame, LLMThinkingTextFrame):
+            await self._handle_thinking(frame)
+        elif isinstance(frame, LLMThinkingSignatureFrame):
+            await self._handle_thinking_signature(frame)
         elif isinstance(frame, LLMRunFrame):
             await self._handle_llm_run(frame)
         elif isinstance(frame, LLMMessagesAppendFrame):
@@ -663,6 +675,14 @@ class LLMAssistantAggregator(LLMContextAggregator):
         timestamp_frame = LLMContextAssistantTimestampFrame(timestamp=time_now_iso8601())
         await self.push_frame(timestamp_frame)
 
+    def thinking_string(self) -> str:
+        """Get the current thinking as a string.
+
+        Returns:
+            The concatenated thinking string.
+        """
+        return concatenate_aggregated_text(self._thinking)
+
     async def _handle_llm_run(self, frame: LLMRunFrame):
         await self.push_context_frame(FrameDirection.UPSTREAM)
 
@@ -824,6 +844,35 @@ class LLMAssistantAggregator(LLMContextAggregator):
             )
         )
 
+    async def _handle_thinking(self, frame: LLMThinkingTextFrame):
+        if not self._started:
+            return
+
+        # Make sure we really have text (spaces count, too!)
+        if len(frame.thinking) == 0:
+            return
+
+        self._thinking.append(
+            TextPartForConcatenation(
+                frame.thinking, includes_inter_part_spaces=frame.includes_inter_frame_spaces
+            )
+        )
+
+    async def _handle_thinking_signature(self, frame: LLMThinkingSignatureFrame):
+        if not self._started:
+            return
+
+        thinking = self.thinking_string()
+
+        self._context.add_message(
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "thinking", "thinking": thinking, "signature": frame.signature},
+                ],
+            }
+        )
+
     def _context_updated_task_finished(self, task: asyncio.Task):
         self._context_updated_tasks.discard(task)
 

src/pipecat/runner/run.py

@@ -302,7 +302,7 @@ def _setup_webrtc_routes(
         result: StartBotResult = {"sessionId": session_id}
         if request_data.get("enableDefaultIceServers"):
             result["iceConfig"] = IceConfig(
-                iceServers=[IceServer(urls="stun:stun.l.google.com:19302")]
+                iceServers=[IceServer(urls=["stun:stun.l.google.com:19302"])]
             )
 
         return result

src/pipecat/services/anthropic/llm.py

@@ -40,6 +40,8 @@ from pipecat.frames.frames import (
     LLMFullResponseStartFrame,
     LLMMessagesFrame,
     LLMTextFrame,
+    LLMThinkingSignatureFrame,
+    LLMThinkingTextFrame,
     LLMUpdateSettingsFrame,
     UserImageRawFrame,
 )
@@ -327,7 +329,7 @@ class AnthropicLLMService(LLMService):
         cache_read_input_tokens = 0
 
         try:
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
             await self.start_processing_metrics()
 
             params_from_context = self._get_llm_invocation_params(context)
@@ -373,15 +375,17 @@ class AnthropicLLMService(LLMService):
 
                 if event.type == "content_block_delta":
                     if hasattr(event.delta, "text"):
-                        await self.push_frame(
-                            LLMTextFrame(event.delta.text, skip_tts=self._get_skip_tts())
-                        )
+                        await self.push_frame(LLMTextFrame(event.delta.text))
                         completion_tokens_estimate += self._estimate_tokens(event.delta.text)
                     elif hasattr(event.delta, "partial_json") and tool_use_block:
                         json_accumulator += event.delta.partial_json
                         completion_tokens_estimate += self._estimate_tokens(
                             event.delta.partial_json
                         )
+                    elif hasattr(event.delta, "thinking"):
+                        await self.push_frame(LLMThinkingTextFrame(event.delta.thinking))
+                    elif hasattr(event.delta, "signature"):
+                        await self.push_frame(LLMThinkingSignatureFrame(event.delta.signature))
                 elif event.type == "content_block_start":
                     if event.content_block.type == "tool_use":
                         tool_use_block = event.content_block
@@ -463,7 +467,7 @@ class AnthropicLLMService(LLMService):
             await self.push_error(error_msg=f"Unknown error occurred: {e}", exception=e)
         finally:
             await self.stop_processing_metrics()
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
             comp_tokens = (
                 completion_tokens
                 if not use_completion_tokens_estimate

src/pipecat/services/aws/agent_core.py

@@ -172,7 +172,7 @@ class AWSAgentCoreProcessor(FrameProcessor):
         await asyncio.sleep(self._output_response_timeout)
         if self._output_response_open:
             self._output_response_open = False
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
 
     async def _push_text_frame(self, text: str):
         """Push a text frame, managing output response bookends."""
@@ -182,11 +182,11 @@ class AWSAgentCoreProcessor(FrameProcessor):
 
         # Open output response if needed
         if not self._output_response_open:
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
             self._output_response_open = True
 
         # Push the text frame
-        await self.push_frame(LLMTextFrame(text, skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMTextFrame(text))
         self._last_text_frame_time = asyncio.get_event_loop().time()
 
         # Schedule closing the output response after timeout
@@ -253,6 +253,6 @@ class AWSAgentCoreProcessor(FrameProcessor):
                     if self._close_task and not self._close_task.done():
                         await self.cancel_task(self._close_task)
                     self._output_response_open = False
-                    await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+                    await self.push_frame(LLMFullResponseEndFrame())
         else:
             await self.push_frame(frame, direction)

src/pipecat/services/aws/llm.py

@@ -981,7 +981,7 @@ class AWSBedrockLLMService(LLMService):
         using_noop_tool = False
 
         try:
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
             await self.start_processing_metrics()
 
             await self.start_ttfb_metrics()
@@ -1078,9 +1078,7 @@ class AWSBedrockLLMService(LLMService):
                     if "contentBlockDelta" in event:
                         delta = event["contentBlockDelta"]["delta"]
                         if "text" in delta:
-                            await self.push_frame(
-                                LLMTextFrame(delta["text"], skip_tts=self._get_skip_tts())
-                            )
+                            await self.push_frame(LLMTextFrame(delta["text"]))
                             completion_tokens_estimate += self._estimate_tokens(delta["text"])
                         elif "toolUse" in delta and "input" in delta["toolUse"]:
                             # Handle partial JSON for tool use
@@ -1141,7 +1139,7 @@ class AWSBedrockLLMService(LLMService):
             await self.push_error(error_msg=f"Unknown error occurred: {e}", exception=e)
         finally:
             await self.stop_processing_metrics()
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
             comp_tokens = (
                 completion_tokens
                 if not use_completion_tokens_estimate

src/pipecat/services/aws/nova_sonic/llm.py

@@ -1016,7 +1016,7 @@ class AWSNovaSonicLLMService(LLMService):
         logger.debug("Assistant response started")
 
         # Report the start of the assistant response.
-        await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseStartFrame())
 
         # Report that equivalent of TTS (this is a speech-to-speech model) started
         await self.push_frame(TTSStartedFrame())
@@ -1062,7 +1062,7 @@ class AWSNovaSonicLLMService(LLMService):
                 # We also need to re-push the LLMFullResponseStartFrame since the
                 # TTSTextFrame would be ignored otherwise (the interruption frame
                 # would have cleared the assistant aggregator state).
-                await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseStartFrame())
                 frame = TTSTextFrame(
                     self._assistant_text_buffer, aggregated_by=AggregationType.SENTENCE
                 )
@@ -1071,7 +1071,7 @@ class AWSNovaSonicLLMService(LLMService):
             self._may_need_repush_assistant_text = False
 
         # Report the end of the assistant response.
-        await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseEndFrame())
 
         # Report that equivalent of TTS (this is a speech-to-speech model) stopped.
         await self.push_frame(TTSStoppedFrame())

src/pipecat/services/aws/stt.py

@@ -58,7 +58,7 @@ class AWSTranscribeSTTService(STTService):
         api_key: Optional[str] = None,
         aws_access_key_id: Optional[str] = None,
         aws_session_token: Optional[str] = None,
-        region: Optional[str] = "us-east-1",
+        region: Optional[str] = None,
         sample_rate: int = 16000,
         language: Language = Language.EN,
         **kwargs,
@@ -69,7 +69,7 @@ class AWSTranscribeSTTService(STTService):
             api_key: AWS secret access key. If None, uses AWS_SECRET_ACCESS_KEY environment variable.
             aws_access_key_id: AWS access key ID. If None, uses AWS_ACCESS_KEY_ID environment variable.
             aws_session_token: AWS session token for temporary credentials. If None, uses AWS_SESSION_TOKEN environment variable.
-            region: AWS region for the service. Defaults to "us-east-1".
+            region: AWS region for the service.
             sample_rate: Audio sample rate in Hz. Must be 8000 or 16000. Defaults to 16000.
             language: Language for transcription. Defaults to English.
             **kwargs: Additional arguments passed to parent STTService class.

src/pipecat/services/google/gemini_live/llm.py

@@ -1448,11 +1448,11 @@ class GeminiLiveLLMService(LLMService):
                 # Update bot responding state and send service start frame
                 # (AUDIO modality case)
                 await self._set_bot_is_responding(True)
-                await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseStartFrame())
 
             self._bot_text_buffer += text
             self._search_result_buffer += text  # Also accumulate for grounding
-            frame = LLMTextFrame(text=text, skip_tts=self._get_skip_tts())
+            frame = LLMTextFrame(text=text)
             await self.push_frame(frame)
 
         # Check for grounding metadata in server content
@@ -1491,7 +1491,7 @@ class GeminiLiveLLMService(LLMService):
         if not self._bot_is_responding:
             await self._set_bot_is_responding(True)
             await self.push_frame(TTSStartedFrame())
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
 
         self._bot_audio_buffer.extend(audio)
         frame = TTSAudioRawFrame(
@@ -1552,10 +1552,10 @@ class GeminiLiveLLMService(LLMService):
             if not text:
                 # AUDIO modality case
                 await self.push_frame(TTSStoppedFrame())
-                await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseEndFrame())
             else:
                 # TEXT modality case
-                await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseEndFrame())
 
     @traced_stt
     async def _handle_user_transcription(
@@ -1643,7 +1643,7 @@ class GeminiLiveLLMService(LLMService):
         if not self._bot_is_responding:
             await self._set_bot_is_responding(True)
             await self.push_frame(TTSStartedFrame())
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
 
         frame = TTSTextFrame(text=text, aggregated_by=AggregationType.SENTENCE)
         # Gemini Live text already includes any necessary inter-chunk spaces

src/pipecat/services/google/llm.py

@@ -876,7 +876,7 @@ class GoogleLLMService(LLMService):
 
     @traced_llm
     async def _process_context(self, context: OpenAILLMContext | LLMContext):
-        await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseStartFrame())
 
         prompt_tokens = 0
         completion_tokens = 0
@@ -920,9 +920,7 @@ class GoogleLLMService(LLMService):
                         for part in candidate.content.parts:
                             if not part.thought and part.text:
                                 search_result += part.text
-                                await self.push_frame(
-                                    LLMTextFrame(part.text, skip_tts=self._get_skip_tts())
-                                )
+                                await self.push_frame(LLMTextFrame(part.text))
                             elif part.function_call:
                                 function_call = part.function_call
                                 id = function_call.id or str(uuid.uuid4())
@@ -1004,7 +1002,7 @@ class GoogleLLMService(LLMService):
                     reasoning_tokens=reasoning_tokens,
                 )
             )
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         """Process incoming frames and handle different frame types.

src/pipecat/services/google/llm_openai.py

@@ -136,9 +136,7 @@ class GoogleLLMOpenAIBetaService(OpenAILLMService):
                     # Keep iterating through the response to collect all the argument fragments
                     arguments += tool_call.function.arguments
             elif chunk.choices[0].delta.content:
-                await self.push_frame(
-                    LLMTextFrame(chunk.choices[0].delta.content, skip_tts=self._get_skip_tts())
-                )
+                await self.push_frame(LLMTextFrame(chunk.choices[0].delta.content))
 
         # if we got a function name and arguments, check to see if it's a function with
         # a registered handler. If so, run the registered callback, save the result to

src/pipecat/services/llm_service.py

@@ -9,7 +9,17 @@
 import asyncio
 import inspect
 from dataclasses import dataclass
-from typing import Any, Awaitable, Callable, Dict, Mapping, Optional, Protocol, Sequence, Type
+from typing import (
+    Any,
+    Awaitable,
+    Callable,
+    Dict,
+    Mapping,
+    Optional,
+    Protocol,
+    Sequence,
+    Type,
+)
 
 from loguru import logger
 
@@ -275,13 +285,17 @@ class LLMService(AIService):
         elif isinstance(frame, LLMConfigureOutputFrame):
             self._skip_tts = frame.skip_tts
 
-    def _get_skip_tts(self) -> bool:
-        """Get the current skip_tts configuration.
+    async def push_frame(self, frame: Frame, direction: FrameDirection = FrameDirection.DOWNSTREAM):
+        """Pushes a frame.
 
-        Returns:
-            The current skip_tts setting for frames generated by this LLM.
+        Args:
+            frame: The frame to push.
+            direction: The direction of frame pushing.
         """
-        return self._skip_tts
+        if isinstance(frame, (LLMTextFrame, LLMFullResponseStartFrame, LLMFullResponseEndFrame)):
+            frame.skip_tts = self._skip_tts
+
+        await super().push_frame(frame, direction)
 
     async def _handle_interruptions(self, _: InterruptionFrame):
         for function_name, entry in self._functions.items():

src/pipecat/services/openai/base_llm.py

@@ -13,7 +13,13 @@ from typing import Any, Dict, List, Mapping, Optional
 
 import httpx
 from loguru import logger
-from openai import NOT_GIVEN, APITimeoutError, AsyncOpenAI, AsyncStream, DefaultAsyncHttpxClient
+from openai import (
+    NOT_GIVEN,
+    APITimeoutError,
+    AsyncOpenAI,
+    AsyncStream,
+    DefaultAsyncHttpxClient,
+)
 from openai.types.chat import ChatCompletionChunk, ChatCompletionMessageParam
 from pydantic import BaseModel, Field
 
@@ -390,20 +396,14 @@ class BaseOpenAILLMService(LLMService):
                     # Keep iterating through the response to collect all the argument fragments
                     arguments += tool_call.function.arguments
             elif chunk.choices[0].delta.content:
-                await self.push_frame(
-                    LLMTextFrame(chunk.choices[0].delta.content, skip_tts=self._get_skip_tts())
-                )
+                await self.push_frame(LLMTextFrame(chunk.choices[0].delta.content))
 
             # When gpt-4o-audio / gpt-4o-mini-audio is used for llm or stt+llm
             # we need to get LLMTextFrame for the transcript
             elif hasattr(chunk.choices[0].delta, "audio") and chunk.choices[0].delta.audio.get(
                 "transcript"
             ):
-                await self.push_frame(
-                    LLMTextFrame(
-                        chunk.choices[0].delta.audio["transcript"], skip_tts=self._get_skip_tts()
-                    )
-                )
+                await self.push_frame(LLMTextFrame(chunk.choices[0].delta.audio["transcript"]))
 
         # if we got a function name and arguments, check to see if it's a function with
         # a registered handler. If so, run the registered callback, save the result to
@@ -463,11 +463,11 @@ class BaseOpenAILLMService(LLMService):
 
         if context:
             try:
-                await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseStartFrame())
                 await self.start_processing_metrics()
                 await self._process_context(context)
             except httpx.TimeoutException:
                 await self._call_event_handler("on_completion_timeout")
             finally:
                 await self.stop_processing_metrics()
-                await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+                await self.push_frame(LLMFullResponseEndFrame())

src/pipecat/services/openai/realtime/llm.py

@@ -15,7 +15,9 @@ from typing import Optional
 from loguru import logger
 
 from pipecat.adapters.schemas.tools_schema import ToolsSchema
-from pipecat.adapters.services.open_ai_realtime_adapter import OpenAIRealtimeLLMAdapter
+from pipecat.adapters.services.open_ai_realtime_adapter import (
+    OpenAIRealtimeLLMAdapter,
+)
 from pipecat.frames.frames import (
     AggregationType,
     BotStoppedSpeakingFrame,
@@ -282,7 +284,7 @@ class OpenAIRealtimeLLMService(LLMService):
         await self._truncate_current_audio_response()
         await self.stop_all_metrics()
         if self._current_assistant_response:
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
             # Only push TTSStoppedFrame if audio modality is enabled
             if self._is_modality_enabled("audio"):
                 await self.push_frame(TTSStoppedFrame())
@@ -606,7 +608,7 @@ class OpenAIRealtimeLLMService(LLMService):
 
         if evt.item.role == "assistant":
             self._current_assistant_response = evt.item
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
 
     async def _handle_evt_conversation_item_done(self, evt):
         """Handle conversation.item.done event - item is fully completed."""
@@ -667,7 +669,7 @@ class OpenAIRealtimeLLMService(LLMService):
         )
         await self.start_llm_usage_metrics(tokens)
         await self.stop_processing_metrics()
-        await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseEndFrame())
         self._current_assistant_response = None
         # error handling
         if evt.response.status == "failed":
@@ -681,7 +683,7 @@ class OpenAIRealtimeLLMService(LLMService):
         # We receive text deltas (as opposed to audio transcript deltas) when
         # the output modality is "text"
         if evt.delta:
-            frame = LLMTextFrame(evt.delta, skip_tts=self._get_skip_tts())
+            frame = LLMTextFrame(evt.delta)
             await self.push_frame(frame)
 
     async def _handle_evt_audio_transcript_delta(self, evt):
@@ -815,7 +817,7 @@ class OpenAIRealtimeLLMService(LLMService):
 
         logger.debug("Creating response")
 
-        await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseStartFrame())
         await self.start_processing_metrics()
         await self.start_ttfb_metrics()
         await self.send_client_event(

src/pipecat/services/openai_realtime_beta/openai.py

@@ -265,7 +265,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         await self._truncate_current_audio_response()
         await self.stop_all_metrics()
         if self._current_assistant_response:
-            await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseEndFrame())
             # Only push TTSStoppedFrame if audio modality is enabled
             if self._is_modality_enabled("audio"):
                 await self.push_frame(TTSStoppedFrame())
@@ -564,7 +564,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
             self._user_and_response_message_tuple = (evt.item, {"done": False, "output": []})
         elif evt.item.role == "assistant":
             self._current_assistant_response = evt.item
-            await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMFullResponseStartFrame())
 
     async def _handle_evt_input_audio_transcription_delta(self, evt):
         if self._send_transcription_frames:
@@ -623,7 +623,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
         )
         await self.start_llm_usage_metrics(tokens)
         await self.stop_processing_metrics()
-        await self.push_frame(LLMFullResponseEndFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseEndFrame())
         self._current_assistant_response = None
         # error handling
         if evt.response.status == "failed":
@@ -647,11 +647,11 @@ class OpenAIRealtimeBetaLLMService(LLMService):
 
     async def _handle_evt_text_delta(self, evt):
         if evt.delta:
-            await self.push_frame(LLMTextFrame(evt.delta, skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMTextFrame(evt.delta))
 
     async def _handle_evt_audio_transcript_delta(self, evt):
         if evt.delta:
-            await self.push_frame(LLMTextFrame(evt.delta, skip_tts=self._get_skip_tts()))
+            await self.push_frame(LLMTextFrame(evt.delta))
             await self.push_frame(TTSTextFrame(evt.delta, aggregated_by=AggregationType.SENTENCE))
 
     async def _handle_evt_speech_started(self, evt):
@@ -747,7 +747,7 @@ class OpenAIRealtimeBetaLLMService(LLMService):
 
         logger.debug(f"Creating response: {self._context.get_messages_for_logging()}")
 
-        await self.push_frame(LLMFullResponseStartFrame(skip_tts=self._get_skip_tts()))
+        await self.push_frame(LLMFullResponseStartFrame())
         await self.start_processing_metrics()
         await self.start_ttfb_metrics()
         await self.send_client_event(

src/pipecat/services/sambanova/llm.py

@@ -14,7 +14,9 @@ from openai import AsyncStream
 from openai.types.chat import ChatCompletionChunk
 
 from pipecat.adapters.services.open_ai_adapter import OpenAILLMInvocationParams
-from pipecat.frames.frames import LLMTextFrame
+from pipecat.frames.frames import (
+    LLMTextFrame,
+)
 from pipecat.metrics.metrics import LLMTokenUsage
 from pipecat.processors.aggregators.llm_context import LLMContext
 from pipecat.processors.aggregators.openai_llm_context import OpenAILLMContext
@@ -174,20 +176,14 @@ class SambaNovaLLMService(OpenAILLMService):  # type: ignore
                     # Keep iterating through the response to collect all the argument fragments
                     arguments += tool_call.function.arguments
             elif chunk.choices[0].delta.content:
-                await self.push_frame(
-                    LLMTextFrame(chunk.choices[0].delta.content, skip_tts=self._get_skip_tts())
-                )
+                await self.push_frame(LLMTextFrame(chunk.choices[0].delta.content))
 
             # When gpt-4o-audio / gpt-4o-mini-audio is used for llm or stt+llm
             # we need to get LLMTextFrame for the transcript
             elif hasattr(chunk.choices[0].delta, "audio") and chunk.choices[0].delta.audio.get(
                 "transcript"
             ):
-                await self.push_frame(
-                    LLMTextFrame(
-                        chunk.choices[0].delta.audio["transcript"], skip_tts=self._get_skip_tts()
-                    )
-                )
+                await self.push_frame(LLMTextFrame(chunk.choices[0].delta.audio["transcript"]))
 
         # if we got a function name and arguments, check to see if it's a function with
         # a registered handler. If so, run the registered callback, save the result to