Fix: Properly close OpenAI SSE stream on interruption

When an InterruptionFrame causes task cancellation, the OpenAI AsyncStream was not being properly closed, which could lead to connection leaks and inconsistent stream state. This fix wraps the stream processing in a try/except/finally block to: - Catch asyncio.CancelledError from interruptions - Ensure the stream is always closed via chunk_stream.close() - Log the cancellation for debugging purposes This prevents SSE connection leaks when users interrupt the bot mid-response.
2025-10-22 09:25:44 +08:00
21 changed files with 192 additions and 881 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,24 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

-### Changed
-
- `FunctionFilter` now has a `filter_system_frames` arg, which controls whether
-  or not SystemFrames are filtered.
-
- Upgraded `aws_sdk_bedrock_runtime` to v0.1.1 to resolve potential CPU issues
-  when running `AWSNovaSonicLLMService`.
-
-### Fixed
-
- Fixed an issue in the runner where starting a DailyTransport room via
-  `/start` didn't support using the `DAILY_SAMPLE_ROOM_URL` env var.
-
- Fixed an issue in `ServiceSwitcher` where the `STTService`s would result in
-  all STT services producing `TranscriptionFrame`s.
-
-## [0.0.91] - 2025-10-21
-
 ### Added

 - It is now possible to start a bot from the `/start` endpoint when using the
--- a/examples/foundational/48-service-switcher.py
+++ b/examples/foundational/48-service-switcher.py
@@ -1,153 +0,0 @@
-#
-# Copyright (c) 2024–2025, Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-import asyncio
-import os
-
-from dotenv import load_dotenv
-from loguru import logger
-
-from pipecat.audio.turn.smart_turn.base_smart_turn import SmartTurnParams
-from pipecat.audio.turn.smart_turn.local_smart_turn_v3 import LocalSmartTurnAnalyzerV3
-from pipecat.audio.vad.silero import SileroVADAnalyzer
-from pipecat.audio.vad.vad_analyzer import VADParams
-from pipecat.frames.frames import LLMRunFrame, ManuallySwitchServiceFrame
-from pipecat.pipeline.pipeline import Pipeline
-from pipecat.pipeline.runner import PipelineRunner
-from pipecat.pipeline.service_switcher import ServiceSwitcher, ServiceSwitcherStrategyManual
-from pipecat.pipeline.task import PipelineParams, PipelineTask
-from pipecat.processors.aggregators.llm_context import LLMContext
-from pipecat.processors.aggregators.llm_response_universal import LLMContextAggregatorPair
-from pipecat.runner.types import RunnerArguments
-from pipecat.runner.utils import create_transport
-from pipecat.services.cartesia.stt import CartesiaSTTService
-from pipecat.services.cartesia.tts import CartesiaTTSService
-from pipecat.services.deepgram.stt import DeepgramSTTService
-from pipecat.services.deepgram.tts import DeepgramTTSService
-from pipecat.services.google.llm import GoogleLLMService
-from pipecat.services.openai.llm import OpenAILLMService
-from pipecat.transports.base_transport import BaseTransport, TransportParams
-from pipecat.transports.daily.transport import DailyParams
-from pipecat.transports.websocket.fastapi import FastAPIWebsocketParams
-
-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)),
-        turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams()),
-    ),
-    "twilio": lambda: FastAPIWebsocketParams(
-        audio_in_enabled=True,
-        audio_out_enabled=True,
-        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
-        turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams()),
-    ),
-    "webrtc": lambda: TransportParams(
-        audio_in_enabled=True,
-        audio_out_enabled=True,
-        vad_analyzer=SileroVADAnalyzer(params=VADParams(stop_secs=0.2)),
-        turn_analyzer=LocalSmartTurnAnalyzerV3(params=SmartTurnParams()),
-    ),
-}
-
-
-async def run_bot(transport: BaseTransport, runner_args: RunnerArguments):
-    logger.info(f"Starting bot")
-
-    stt_cartesia = CartesiaSTTService(api_key=os.getenv("CARTESIA_API_KEY"))
-    stt_deepgram = DeepgramSTTService(api_key=os.getenv("DEEPGRAM_API_KEY"))
-    stt_switcher = ServiceSwitcher(
-        services=[stt_cartesia, stt_deepgram], strategy_type=ServiceSwitcherStrategyManual
-    )
-
-    tts_cartesia = CartesiaTTSService(
-        api_key=os.getenv("CARTESIA_API_KEY"),
-        voice_id="71a7ad14-091c-4e8e-a314-022ece01c121",
-    )
-    tts_deepgram = DeepgramTTSService(api_key=os.getenv("DEEPGRAM_API_KEY"))
-    tts_switcher = ServiceSwitcher(
-        services=[tts_cartesia, tts_deepgram], strategy_type=ServiceSwitcherStrategyManual
-    )
-
-    llm_openai = OpenAILLMService(api_key=os.getenv("OPENAI_API_KEY"))
-    llm_google = GoogleLLMService(api_key=os.getenv("GOOGLE_API_KEY"))
-    llm_switcher = ServiceSwitcher(
-        services=[llm_openai, llm_google], strategy_type=ServiceSwitcherStrategyManual
-    )
-
-    messages = [
-        {
-            "role": "system",
-            "content": "You are a helpful LLM in a WebRTC call. Your goal is to demonstrate your capabilities in a succinct way. Your output will be converted to audio so don't include special characters in your answers. Respond to what the user said in a creative and helpful way.",
-        },
-    ]
-
-    context = LLMContext(messages)
-    context_aggregator = LLMContextAggregatorPair(context)
-
-    pipeline = Pipeline(
-        [
-            transport.input(),  # Transport user input
-            stt_switcher,
-            context_aggregator.user(),  # User responses
-            llm_switcher,  # LLM
-            tts_switcher,  # TTS
-            transport.output(),  # Transport bot output
-            context_aggregator.assistant(),  # 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()])
-        await asyncio.sleep(15)
-        print(f"Switching to {stt_deepgram}")
-        await task.queue_frames([ManuallySwitchServiceFrame(service=stt_deepgram)])
-        await asyncio.sleep(15)
-        print(f"Switching to {llm_google}")
-        await task.queue_frames([ManuallySwitchServiceFrame(service=llm_google)])
-        await asyncio.sleep(15)
-        print(f"Switching to {tts_deepgram}")
-        await task.queue_frames([ManuallySwitchServiceFrame(service=tts_deepgram)])
-
-    @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/quickstart/README.md
+++ b/examples/quickstart/README.md
@@ -73,13 +73,13 @@ Transform your local bot into a production-ready service. Pipecat Cloud handles

 1. [Sign up for Pipecat Cloud](https://pipecat.daily.co/sign-up).

-2. Install the Pipecat CLI:
+2. Install the Pipecat Cloud CLI:

   ```bash
-   uv tool install pipecat-ai-cli
+   uv add pipecatcloud
   ```

-> 💡 Tip: You can run the `pipecat` CLI using the `pc` alias.
+> 💡 Tip: You can run the `pipecatcloud` CLI using the `pcc` alias.

 3. Set up Docker for building your bot image:

@@ -113,22 +113,12 @@ secret_set = "quickstart-secrets"

 > 💡 Tip: [Set up `image_credentials`](https://docs.pipecat.ai/deployment/pipecat-cloud/fundamentals/secrets#image-pull-secrets) in your TOML file for authenticated image pulls

-### Log in to Pipecat Cloud
-
-To start using the CLI, authenticate to Pipecat Cloud:
-
-```bash
-pipecat cloud auth login
-```
-
-You'll be presented with a link that you can click to authenticate your client.
-
 ### Configure secrets

 Upload your API keys to Pipecat Cloud's secure storage:

 ```bash
-pipecat cloud secrets set quickstart-secrets --file .env
+uv run pcc secrets set quickstart-secrets --file .env
 ```

 This creates a secret set called `quickstart-secrets` (matching your TOML file) and uploads all your API keys from `.env`.
@@ -138,13 +128,13 @@ This creates a secret set called `quickstart-secrets` (matching your TOML file)
 Build your Docker image and push to Docker Hub:

 ```bash
-pipecat cloud docker build-push
+uv run pcc docker build-push
 ```

 Deploy to Pipecat Cloud:

 ```bash
-pipecat cloud deploy
+uv run pcc deploy
 ```

 ### Connect to your agent
--- a/examples/quickstart/pcc-deploy.toml
+++ b/examples/quickstart/pcc-deploy.toml
@@ -1,11 +1,6 @@
 agent_name = "quickstart"
 image = "your_username/quickstart:0.1"
 secret_set = "quickstart-secrets"
-agent_profile = "agent-1x"
-
-# RECOMMENDED: Set an image pull secret:
-# https://docs.pipecat.ai/deployment/pipecat-cloud/fundamentals/secrets#image-pull-secrets
-# image_credentials = "your_image_pull_secret"

 [scaling]
 	min_agents = 1
--- a/examples/quickstart/pyproject.toml
+++ b/examples/quickstart/pyproject.toml
@@ -4,14 +4,13 @@ version = "0.1.0"
 description = "Quickstart example for building voice AI bots with Pipecat"
 requires-python = ">=3.10"
 dependencies = [
-    "pipecat-ai[webrtc,daily,silero,deepgram,openai,cartesia,local-smart-turn-v3,runner]",
-    "pipecat-ai-cli"
+    "pipecat-ai[webrtc,daily,silero,deepgram,openai,cartesia,local-smart-turn-v3,runner]>=0.0.86",
+    "pipecatcloud>=0.2.4"
 ]

 [dependency-groups]
 dev = [
-    "pyright>=1.1.404,<2",
-    "ruff>=0.12.11,<1",
+    "ruff~=0.12.1",
 ]

 [tool.ruff]
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -50,7 +50,7 @@ anthropic = [ "anthropic~=0.49.0" ]
 assemblyai = [ "pipecat-ai[websockets-base]" ]
 asyncai = [ "pipecat-ai[websockets-base]" ]
 aws = [ "aioboto3~=15.0.0", "pipecat-ai[websockets-base]" ]
-aws-nova-sonic = [ "aws_sdk_bedrock_runtime~=0.1.1; python_version>='3.12'" ]
+aws-nova-sonic = [ "aws_sdk_bedrock_runtime~=0.1.0; python_version>='3.12'" ]
 azure = [ "azure-cognitiveservices-speech~=1.42.0"]
 cartesia = [ "cartesia~=2.0.3", "pipecat-ai[websockets-base]" ]
 cerebras = []
--- a/src/pipecat/adapters/services/anthropic_adapter.py
+++ b/src/pipecat/adapters/services/anthropic_adapter.py
@@ -110,7 +110,7 @@ class AnthropicLLMAdapter(BaseLLMAdapter[AnthropicLLMInvocationParams]):
        system = NOT_GIVEN
        messages = []

-        # First, map messages using self._from_universal_context_message(m)
+        # first, map messages using self._from_universal_context_message(m)
        try:
            messages = [self._from_universal_context_message(m) for m in universal_context_messages]
        except Exception as e:
--- a/src/pipecat/adapters/services/bedrock_adapter.py
+++ b/src/pipecat/adapters/services/bedrock_adapter.py
@@ -107,7 +107,7 @@ class AWSBedrockLLMAdapter(BaseLLMAdapter[AWSBedrockLLMInvocationParams]):
        system = None
        messages = []

-        # First, map messages using self._from_universal_context_message(m)
+        # first, map messages using self._from_universal_context_message(m)
        try:
            messages = [self._from_universal_context_message(m) for m in universal_context_messages]
        except Exception as e:
--- a/src/pipecat/adapters/services/gemini_adapter.py
+++ b/src/pipecat/adapters/services/gemini_adapter.py
@@ -8,8 +8,8 @@

 import base64
 import json
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple, TypedDict
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, TypedDict

 from loguru import logger
 from openai import NotGiven
@@ -133,28 +133,6 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
        messages: List[Content]
        system_instruction: Optional[str] = None

-    @dataclass
-    class MessageConversionResult:
-        """Result of converting a single universal context message to Google format.
-
-        Either content (a Google Content object) or a system instruction string
-        is guaranteed to be set.
-
-        Also returns a tool call ID to name mapping for any tool calls
-        discovered in the message.
-        """
-
-        content: Optional[Content] = None
-        system_instruction: Optional[str] = None
-        tool_call_id_to_name_mapping: Dict[str, str] = field(default_factory=dict)
-
-    @dataclass
-    class MessageConversionParams:
-        """Parameters for converting a single universal context message to Google format."""
-
-        already_have_system_instruction: bool
-        tool_call_id_to_name_mapping: Dict[str, str]
-
    def _from_universal_context_messages(
        self, universal_context_messages: List[LLMContextMessage]
    ) -> ConvertedMessages:
@@ -178,26 +156,24 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
        """
        system_instruction = None
        messages = []
-        tool_call_id_to_name_mapping = {}

        # Process each message, preserving Google-formatted messages and converting others
        for message in universal_context_messages:
-            result = self._from_universal_context_message(
-                message,
-                params=self.MessageConversionParams(
-                    already_have_system_instruction=bool(system_instruction),
-                    tool_call_id_to_name_mapping=tool_call_id_to_name_mapping,
-                ),
-            )
-            # Each result is either a Content or a system instruction
-            if result.content:
-                messages.append(result.content)
-            elif result.system_instruction:
-                system_instruction = result.system_instruction
+            if isinstance(message, LLMSpecificMessage):
+                # Assume that LLMSpecificMessage wraps a message in Google format
+                messages.append(message.message)
+                continue

-            # Merge tool call ID to name mapping
-            if result.tool_call_id_to_name_mapping:
-                tool_call_id_to_name_mapping.update(result.tool_call_id_to_name_mapping)
+            # Convert standard format to Google format
+            converted = self._from_standard_message(
+                message, already_have_system_instruction=bool(system_instruction)
+            )
+            if isinstance(converted, Content):
+                # Regular (non-system) message
+                messages.append(converted)
+            else:
+                # System instruction
+                system_instruction = converted

        # Check if we only have function-related messages (no regular text)
        has_regular_messages = any(
@@ -217,16 +193,9 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):

        return self.ConvertedMessages(messages=messages, system_instruction=system_instruction)

-    def _from_universal_context_message(
-        self, message: LLMContextMessage, *, params: MessageConversionParams
-    ) -> MessageConversionResult:
-        if isinstance(message, LLMSpecificMessage):
-            return self.MessageConversionResult(content=message.message)
-        return self._from_standard_message(message, params=params)
-
    def _from_standard_message(
-        self, message: LLMStandardMessage, *, params: MessageConversionParams
-    ) -> MessageConversionResult:
+        self, message: LLMStandardMessage, already_have_system_instruction: bool
+    ) -> Content | str:
        """Convert standard universal context message to Google Content object.

        Handles conversion of text, images, and function calls to Google's
@@ -236,11 +205,10 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
        Args:
            message: Message in standard universal context format.
            already_have_system_instruction: Whether we already have a system instruction
-            params: Parameters for conversion.

        Returns:
-            MessageConversionResult containing either a Content object or a
-            system instruction string.
+            Content object with role and parts, or a plain string for system
+            messages.

        Examples:
            Standard text message::
@@ -274,48 +242,38 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
            Converts to Google Content with::

                Content(
-                    role="user",
+                    role="model",
                    parts=[Part(function_call=FunctionCall(name="search", args={"query": "test"}))]
                )
        """
        role = message["role"]
        content = message.get("content", [])
-
        if role == "system":
-            if params.already_have_system_instruction:
+            if already_have_system_instruction:
                role = "user"  # Convert system message to user role if we already have a system instruction
            else:
-                system_instruction: str = None
+                # System instructions are returned as plain text
                if isinstance(content, str):
-                    system_instruction = content
+                    return content
                elif isinstance(content, list):
                    # If content is a list, we assume it's a list of text parts, per the standard
-                    system_instruction = " ".join(
-                        part["text"] for part in content if part.get("type") == "text"
-                    )
-                if system_instruction:
-                    return self.MessageConversionResult(system_instruction=system_instruction)
+                    return " ".join(part["text"] for part in content if part.get("type") == "text")
        elif role == "assistant":
            role = "model"

        parts = []
-        tool_call_id_to_name_mapping = {}
-
        if message.get("tool_calls"):
            for tc in message["tool_calls"]:
-                id = tc["id"]
-                name = tc["function"]["name"]
-                tool_call_id_to_name_mapping[id] = name
                parts.append(
                    Part(
                        function_call=FunctionCall(
-                            name=name,
+                            name=tc["function"]["name"],
                            args=json.loads(tc["function"]["arguments"]),
                        )
                    )
                )
        elif role == "tool":
-            role = "user"
+            role = "model"
            try:
                response = json.loads(message["content"])
                if isinstance(response, dict):
@@ -326,17 +284,12 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
                # Response might not be JSON-deserializable.
                # This occurs with a UserImageFrame, for example, where we get a plain "COMPLETED" string.
                response_dict = {"value": message["content"]}
-
-            # Get function name from mapping using tool_call_id, or fallback
-            tool_call_id = message.get("tool_call_id")
-            function_name = "tool_call_result"  # Default fallback
-            if tool_call_id and tool_call_id in params.tool_call_id_to_name_mapping:
-                function_name = params.tool_call_id_to_name_mapping[tool_call_id]
-
            parts.append(
-                Part.from_function_response(
-                    name=function_name,
-                    response=response_dict,
+                Part(
+                    function_response=FunctionResponse(
+                        name="tool_call_result",  # seems to work to hard-code the same name every time
+                        response=response_dict,
+                    )
                )
            )
        elif isinstance(content, str):
@@ -359,7 +312,4 @@ class GeminiLLMAdapter(BaseLLMAdapter[GeminiLLMInvocationParams]):
                    audio_bytes = base64.b64decode(input_audio["data"])
                    parts.append(Part(inline_data=Blob(mime_type="audio/wav", data=audio_bytes)))

-        return self.MessageConversionResult(
-            content=Content(role=role, parts=parts),
-            tool_call_id_to_name_mapping=tool_call_id_to_name_mapping,
-        )
+        return Content(role=role, parts=parts)
--- a/src/pipecat/pipeline/llm_switcher.py
+++ b/src/pipecat/pipeline/llm_switcher.py
@@ -14,41 +14,20 @@ from pipecat.services.llm_service import LLMService


 class LLMSwitcher(ServiceSwitcher[StrategyType]):
-    """A pipeline that switches between different LLMs at runtime.
-
-    Example::
-
-        llm_switcher = LLMSwitcher(
-            llms=[openai_llm, anthropic_llm],
-            strategy_type=ServiceSwitcherStrategyManual
-        )
-    """
+    """A pipeline that switches between different LLMs at runtime."""

    def __init__(self, llms: List[LLMService], strategy_type: Type[StrategyType]):
-        """Initialize the service switcher with a list of LLMs and a switching strategy.
-
-        Args:
-            llms: List of LLM services to switch between.
-            strategy_type: The strategy class to use for switching between LLMs.
-        """
+        """Initialize the service switcher with a list of LLMs and a switching strategy."""
        super().__init__(llms, strategy_type)

    @property
    def llms(self) -> List[LLMService]:
-        """Get the list of LLMs managed by this switcher.
-
-        Returns:
-            List of LLM services managed by this switcher.
-        """
+        """Get the list of LLMs managed by this switcher."""
        return self.services

    @property
    def active_llm(self) -> Optional[LLMService]:
-        """Get the currently active LLM.
-
-        Returns:
-            The currently active LLM service, or None if no LLM is active.
-        """
+        """Get the currently active LLM, if any."""
        return self.strategy.active_service

    async def run_inference(self, context: LLMContext) -> Optional[str]:
--- a/src/pipecat/pipeline/service_switcher.py
+++ b/src/pipecat/pipeline/service_switcher.py
@@ -21,22 +21,10 @@ from pipecat.processors.frame_processor import FrameDirection, FrameProcessor


 class ServiceSwitcherStrategy:
-    """Base class for service switching strategies.
-
-    Note:
-        Strategy classes are instantiated internally by ServiceSwitcher.
-        Developers should pass the strategy class (not an instance) to ServiceSwitcher.
-    """
+    """Base class for service switching strategies."""

    def __init__(self, services: List[FrameProcessor]):
-        """Initialize the service switcher strategy with a list of services.
-
-        Note:
-            This is called internally by ServiceSwitcher. Do not instantiate directly.
-
-        Args:
-            services: List of frame processors to switch between.
-        """
+        """Initialize the service switcher strategy with a list of services."""
        self.services = services
        self.active_service: Optional[FrameProcessor] = None

@@ -58,24 +46,10 @@ class ServiceSwitcherStrategyManual(ServiceSwitcherStrategy):

    This strategy allows the user to manually select which service is active.
    The initial active service is the first one in the list.
-
-    Example::
-
-        stt_switcher = ServiceSwitcher(
-            services=[stt_1, stt_2],
-            strategy_type=ServiceSwitcherStrategyManual
-        )
    """

    def __init__(self, services: List[FrameProcessor]):
-        """Initialize the manual service switcher strategy with a list of services.
-
-        Note:
-            This is called internally by ServiceSwitcher. Do not instantiate directly.
-
-        Args:
-            services: List of frame processors to switch between.
-        """
+        """Initialize the manual service switcher strategy with a list of services."""
        super().__init__(services)
        self.active_service = services[0] if services else None

@@ -111,12 +85,7 @@ class ServiceSwitcher(ParallelPipeline, Generic[StrategyType]):
    """A pipeline that switches between different services at runtime."""

    def __init__(self, services: List[FrameProcessor], strategy_type: Type[StrategyType]):
-        """Initialize the service switcher with a list of services and a switching strategy.
-
-        Args:
-            services: List of frame processors to switch between.
-            strategy_type: The strategy class to use for switching between services.
-        """
+        """Initialize the service switcher with a list of services and a switching strategy."""
        strategy = strategy_type(services)
        super().__init__(*self._make_pipeline_definitions(services, strategy))
        self.services = services
@@ -131,20 +100,14 @@ class ServiceSwitcher(ParallelPipeline, Generic[StrategyType]):
            active_service: FrameProcessor,
            direction: FrameDirection,
        ):
-            """Initialize the service switcher filter with a strategy and direction.
-
-            Args:
-                wrapped_service: The service that this filter wraps.
-                active_service: The currently active service.
-                direction: The direction of frame flow to filter.
-            """
-            self._wrapped_service = wrapped_service
-            self._active_service = active_service
+            """Initialize the service switcher filter with a strategy and direction."""

            async def filter(_: Frame) -> bool:
                return self._wrapped_service == self._active_service

-            super().__init__(filter, direction, filter_system_frames=True)
+            super().__init__(filter, direction)
+            self._wrapped_service = wrapped_service
+            self._active_service = active_service

        async def process_frame(self, frame, direction):
            """Process a frame through the filter, handling special internal filter-updating frames."""
--- a/src/pipecat/pipeline/task_observer.py
+++ b/src/pipecat/pipeline/task_observer.py
@@ -189,7 +189,7 @@ class TaskObserver(BaseObserver):
            if isinstance(data, FramePushed):
                if on_push_frame_deprecated:
                    await observer.on_push_frame(
-                        data.source, data.destination, data.frame, data.direction, data.timestamp
+                        data.src, data.dst, data.frame, data.direction, data.timestamp
                    )
                else:
                    await observer.on_push_frame(data)
--- a/src/pipecat/processors/filters/function_filter.py
+++ b/src/pipecat/processors/filters/function_filter.py
@@ -12,7 +12,7 @@ allowing for flexible frame filtering logic in processing pipelines.

 from typing import Awaitable, Callable

-from pipecat.frames.frames import CancelFrame, EndFrame, Frame, StartFrame, SystemFrame
+from pipecat.frames.frames import EndFrame, Frame, SystemFrame
 from pipecat.processors.frame_processor import FrameDirection, FrameProcessor


@@ -28,7 +28,6 @@ class FunctionFilter(FrameProcessor):
        self,
        filter: Callable[[Frame], Awaitable[bool]],
        direction: FrameDirection = FrameDirection.DOWNSTREAM,
-        filter_system_frames: bool = False,
    ):
        """Initialize the function filter.

@@ -37,32 +36,22 @@ class FunctionFilter(FrameProcessor):
                frame should pass through, False otherwise.
            direction: The direction to apply filtering. Only frames moving in
                this direction will be filtered. Defaults to DOWNSTREAM.
-            filter_system_frames: Whether to filter system frames. Defaults to False.
        """
        super().__init__()
        self._filter = filter
        self._direction = direction
-        self._filter_system_frames = filter_system_frames

    #
    # Frame processor
    #

+    # Ignore system frames, end frames and frames that are not following the
+    # direction of this gate
    def _should_passthrough_frame(self, frame, direction):
        """Check if a frame should pass through without filtering."""
-        # Always passthrough frames in the wrong direction
-        if direction != self._direction:
-            return True
-
-        # Always passthrough lifecycle frames
-        if isinstance(frame, (StartFrame, EndFrame, CancelFrame)):
-            return True
-
-        # If not filtering system frames, passthrough all other system frames
-        if not self._filter_system_frames and isinstance(frame, SystemFrame):
-            return True
-
-        return False
+        # Ignore system frames, end frames and frames that are not following the
+        # direction of this gate
+        return isinstance(frame, (SystemFrame, EndFrame)) or direction != self._direction

    async def process_frame(self, frame: Frame, direction: FrameDirection):
        """Process a frame through the filter.
--- a/src/pipecat/runner/run.py
+++ b/src/pipecat/runner/run.py
@@ -573,14 +573,8 @@ def _setup_daily_routes(app: FastAPI):

        bot_module = _get_bot_module()

-        existing_room_url = os.getenv("DAILY_SAMPLE_ROOM_URL")
-
        result = None
-
-        # Configure room if:
-        # 1. Explicitly requested via createDailyRoom in payload
-        # 2. Using pre-configured room from DAILY_SAMPLE_ROOM_URL env var
-        if create_daily_room or existing_room_url:
+        if create_daily_room:
            import aiohttp

            from pipecat.runner.daily import configure
--- a/src/pipecat/services/google/llm.py
+++ b/src/pipecat/services/google/llm.py
@@ -1034,23 +1034,6 @@ class GoogleLLMService(LLMService):
        if context:
            await self._process_context(context)

-    async def stop(self, frame):
-        """Override stop to gracefully close the client."""
-        await super().stop(frame)
-        await self._close_client()
-
-    async def cancel(self, frame):
-        """Override cancel to gracefully close the client."""
-        await super().cancel(frame)
-        await self._close_client()
-
-    async def _close_client(self):
-        try:
-            await self._client.aio.aclose()
-        except Exception:
-            # Do nothing - we're shutting down anyway
-            pass
-
    def create_context_aggregator(
        self,
        context: OpenAILLMContext,
--- a/src/pipecat/services/openai/base_llm.py
+++ b/src/pipecat/services/openai/base_llm.py
@@ -339,92 +339,100 @@ class BaseOpenAILLMService(LLMService):
            else self._stream_chat_completions_universal_context(context)
        )

-        async for chunk in chunk_stream:
-            if chunk.usage:
-                cached_tokens = (
-                    chunk.usage.prompt_tokens_details.cached_tokens
-                    if chunk.usage.prompt_tokens_details
-                    else None
-                )
-                tokens = LLMTokenUsage(
-                    prompt_tokens=chunk.usage.prompt_tokens,
-                    completion_tokens=chunk.usage.completion_tokens,
-                    total_tokens=chunk.usage.total_tokens,
-                    cache_read_input_tokens=cached_tokens,
-                )
-                await self.start_llm_usage_metrics(tokens)
-
-            if chunk.choices is None or len(chunk.choices) == 0:
-                continue
-
-            await self.stop_ttfb_metrics()
-
-            if not chunk.choices[0].delta:
-                continue
-
-            if chunk.choices[0].delta.tool_calls:
-                # We're streaming the LLM response to enable the fastest response times.
-                # For text, we just yield each chunk as we receive it and count on consumers
-                # to do whatever coalescing they need (eg. to pass full sentences to TTS)
-                #
-                # If the LLM is a function call, we'll do some coalescing here.
-                # If the response contains a function name, we'll yield a frame to tell consumers
-                # that they can start preparing to call the function with that name.
-                # We accumulate all the arguments for the rest of the streamed response, then when
-                # the response is done, we package up all the arguments and the function name and
-                # yield a frame containing the function name and the arguments.
-
-                tool_call = chunk.choices[0].delta.tool_calls[0]
-                if tool_call.index != func_idx:
-                    functions_list.append(function_name)
-                    arguments_list.append(arguments)
-                    tool_id_list.append(tool_call_id)
-                    function_name = ""
-                    arguments = ""
-                    tool_call_id = ""
-                    func_idx += 1
-                if tool_call.function and tool_call.function.name:
-                    function_name += tool_call.function.name
-                    tool_call_id = tool_call.id
-                if tool_call.function and tool_call.function.arguments:
-                    # 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))
-
-            # 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"]))
-
-        # 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
-        # the context, and re-prompt to get a chat answer. If we don't have a registered
-        # handler, raise an exception.
-        if function_name and arguments:
-            # added to the list as last function name and arguments not added to the list
-            functions_list.append(function_name)
-            arguments_list.append(arguments)
-            tool_id_list.append(tool_call_id)
-
-            function_calls = []
-
-            for function_name, arguments, tool_id in zip(
-                functions_list, arguments_list, tool_id_list
-            ):
-                arguments = json.loads(arguments)
-                function_calls.append(
-                    FunctionCallFromLLM(
-                        context=context,
-                        tool_call_id=tool_id,
-                        function_name=function_name,
-                        arguments=arguments,
+        try:
+            async for chunk in chunk_stream:
+                if chunk.usage:
+                    cached_tokens = (
+                        chunk.usage.prompt_tokens_details.cached_tokens
+                        if chunk.usage.prompt_tokens_details
+                        else None
                    )
-                )
+                    tokens = LLMTokenUsage(
+                        prompt_tokens=chunk.usage.prompt_tokens,
+                        completion_tokens=chunk.usage.completion_tokens,
+                        total_tokens=chunk.usage.total_tokens,
+                        cache_read_input_tokens=cached_tokens,
+                    )
+                    await self.start_llm_usage_metrics(tokens)

-            await self.run_function_calls(function_calls)
+                if chunk.choices is None or len(chunk.choices) == 0:
+                    continue
+
+                await self.stop_ttfb_metrics()
+
+                if not chunk.choices[0].delta:
+                    continue
+
+                if chunk.choices[0].delta.tool_calls:
+                    # We're streaming the LLM response to enable the fastest response times.
+                    # For text, we just yield each chunk as we receive it and count on consumers
+                    # to do whatever coalescing they need (eg. to pass full sentences to TTS)
+                    #
+                    # If the LLM is a function call, we'll do some coalescing here.
+                    # If the response contains a function name, we'll yield a frame to tell consumers
+                    # that they can start preparing to call the function with that name.
+                    # We accumulate all the arguments for the rest of the streamed response, then when
+                    # the response is done, we package up all the arguments and the function name and
+                    # yield a frame containing the function name and the arguments.
+
+                    tool_call = chunk.choices[0].delta.tool_calls[0]
+                    if tool_call.index != func_idx:
+                        functions_list.append(function_name)
+                        arguments_list.append(arguments)
+                        tool_id_list.append(tool_call_id)
+                        function_name = ""
+                        arguments = ""
+                        tool_call_id = ""
+                        func_idx += 1
+                    if tool_call.function and tool_call.function.name:
+                        function_name += tool_call.function.name
+                        tool_call_id = tool_call.id
+                    if tool_call.function and tool_call.function.arguments:
+                        # 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))
+
+                # 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"]))
+
+            # 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
+            # the context, and re-prompt to get a chat answer. If we don't have a registered
+            # handler, raise an exception.
+            if function_name and arguments:
+                # added to the list as last function name and arguments not added to the list
+                functions_list.append(function_name)
+                arguments_list.append(arguments)
+                tool_id_list.append(tool_call_id)
+
+                function_calls = []
+
+                for function_name, arguments, tool_id in zip(
+                    functions_list, arguments_list, tool_id_list
+                ):
+                    arguments = json.loads(arguments)
+                    function_calls.append(
+                        FunctionCallFromLLM(
+                            context=context,
+                            tool_call_id=tool_id,
+                            function_name=function_name,
+                            arguments=arguments,
+                        )
+                    )
+
+                await self.run_function_calls(function_calls)
+        except asyncio.CancelledError:
+            # Handle cancellation gracefully (e.g., from InterruptionFrame)
+            logger.debug(f"{self}: Stream processing cancelled due to interruption")
+            raise
+        finally:
+            # Ensure the SSE stream is properly closed to avoid connection leaks
+            await chunk_stream.close()

    async def process_frame(self, frame: Frame, direction: FrameDirection):
        """Process frames for LLM completion requests.
--- a/src/pipecat/tests/init.py
+++ b/src/pipecat/tests/init.py
@@ -1,12 +0,0 @@
-#
-# Copyright (c) 2024-2025 Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-"""Public testing API for Pipecat frame processors."""
-
-from .serialization import dict_to_frame, frame_to_dict, load_frames_from_json
-from .test_runner import run_test_from_file
-
-__all__ = ["dict_to_frame", "frame_to_dict", "load_frames_from_json", "run_test_from_file"]
--- a/src/pipecat/tests/serialization.py
+++ b/src/pipecat/tests/serialization.py
@@ -1,150 +0,0 @@
-#
-# Copyright (c) 2024-2025 Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-"""Frame serialization and deserialization for testing."""
-
-import base64
-import inspect
-import json
-from pathlib import Path
-from typing import Any, Dict, List
-
-from pipecat.frames import frames
-
-
-def _get_frame_class(frame_type: str):
-    """Get a frame class by name from the frames module.
-    
-    Args:
-        frame_type: The name of the frame class (e.g., "TextFrame")
-        
-    Returns:
-        The frame class object
-        
-    Raises:
-        ValueError: If the frame type is not found
-    """
-    if not hasattr(frames, frame_type):
-        raise ValueError(f"Unknown frame type: {frame_type}")
-    
-    cls = getattr(frames, frame_type)
-    if not inspect.isclass(cls) or not issubclass(cls, frames.Frame):
-        raise ValueError(f"{frame_type} is not a valid Frame class")
-    
-    return cls
-
-
-def dict_to_frame(data: Dict[str, Any]) -> frames.Frame:
-    """Convert a dictionary to a Frame object.
-    
-    Args:
-        data: Dictionary containing frame data with a "type" key
-        
-    Returns:
-        A Frame instance
-        
-    Raises:
-        ValueError: If frame type is missing or invalid
-        
-    Example:
-        >>> dict_to_frame({"type": "TextFrame", "text": "hello"})
-        TextFrame(text="hello")
-    """
-    if "type" not in data:
-        raise ValueError("Frame dictionary must contain a 'type' field")
-    
-    frame_type = data["type"]
-    frame_cls = _get_frame_class(frame_type)
-    
-    # Build kwargs from data, excluding 'type'
-    kwargs = {k: v for k, v in data.items() if k != "type"}
-    
-    # Special handling for audio frames with base64 encoded audio
-    if "audio" in kwargs and isinstance(kwargs["audio"], str):
-        kwargs["audio"] = base64.b64decode(kwargs["audio"])
-    
-    # Special handling for image frames with base64 encoded images
-    if "image" in kwargs and isinstance(kwargs["image"], str):
-        kwargs["image"] = base64.b64decode(kwargs["image"])
-    
-    try:
-        return frame_cls(**kwargs)
-    except TypeError as e:
-        raise ValueError(f"Failed to create {frame_type}: {e}")
-
-
-def load_frames_from_json(filepath: str) -> List[frames.Frame]:
-    """Load frames from a JSON file.
-    
-    Args:
-        filepath: Path to JSON file containing frame data
-        
-    Returns:
-        List of Frame objects
-        
-    Raises:
-        FileNotFoundError: If the file doesn't exist
-        ValueError: If JSON is invalid or frames cannot be deserialized
-        
-    Example JSON format:
-        {
-          "input_frames": [
-            {"type": "TextFrame", "text": "hello"},
-            {"type": "EndFrame"}
-          ]
-        }
-    """
-    path = Path(filepath)
-    if not path.exists():
-        raise FileNotFoundError(f"Frame file not found: {filepath}")
-    
-    with open(path, "r") as f:
-        data = json.load(f)
-    
-    if not isinstance(data, dict):
-        raise ValueError("JSON must contain a dictionary")
-    
-    if "input_frames" not in data:
-        raise ValueError("JSON must contain an 'input_frames' key")
-    
-    frame_dicts = data["input_frames"]
-    if not isinstance(frame_dicts, list):
-        raise ValueError("'input_frames' must be a list")
-    
-    return [dict_to_frame(frame_dict) for frame_dict in frame_dicts]
-
-
-def frame_to_dict(frame: frames.Frame) -> Dict[str, Any]:
-    """Convert a Frame object to a dictionary.
-    
-    Args:
-        frame: Frame object to serialize
-        
-    Returns:
-        Dictionary representation of the frame
-        
-    Example:
-        >>> frame_to_dict(TextFrame(text="hello"))
-        {"type": "TextFrame", "text": "hello"}
-    """
-    result = {"type": frame.__class__.__name__}
-    
-    # Get all fields from the dataclass
-    if hasattr(frame, "__dataclass_fields__"):
-        for field_name in frame.__dataclass_fields__:
-            # Skip internal fields from base Frame class
-            if field_name in ("id", "name", "pts", "metadata", "transport_source", "transport_destination"):
-                continue
-            
-            value = getattr(frame, field_name, None)
-            if value is not None:
-                # Special handling for bytes (audio/image data)
-                if isinstance(value, bytes):
-                    result[field_name] = base64.b64encode(value).decode("utf-8")
-                else:
-                    result[field_name] = value
-    
-    return result
--- a/src/pipecat/tests/test_runner.py
+++ b/src/pipecat/tests/test_runner.py
@@ -1,169 +0,0 @@
-#
-# Copyright (c) 2024-2025 Daily
-#
-# SPDX-License-Identifier: BSD 2-Clause License
-#
-
-"""Test runner for frame processors from JSON test files."""
-
-import json
-from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
-
-from pipecat.frames.frames import Frame
-from pipecat.processors.frame_processor import FrameProcessor
-
-from .serialization import dict_to_frame, frame_to_dict, load_frames_from_json
-
-
-async def run_test_from_file(
-    processor: FrameProcessor,
-    test_file: str,
-) -> Tuple[List[Frame], Optional[List[Dict[str, Any]]], bool]:
-    """Run a processor test from a JSON test file.
-
-    Args:
-        processor: The frame processor to test
-        test_file: Path to JSON test file
-
-    Returns:
-        Tuple of (output_frames, expected_output, passed)
-        - output_frames: List of Frame objects that were output
-        - expected_output: List of expected frame dicts (None if not specified)
-        - passed: True if test passed, False if failed, None if no validation
-
-    Raises:
-        FileNotFoundError: If test file doesn't exist
-        ValueError: If test file is invalid
-
-    Example test file format:
-        {
-          "input_frames": [
-            {"type": "TextFrame", "text": "hello"}
-          ],
-          "expected_output": [
-            {"type": "TextFrame"},
-            {"type": "EndFrame"}
-          ]
-        }
-    """
-    path = Path(test_file)
-    if not path.exists():
-        raise FileNotFoundError(f"Test file not found: {test_file}")
-
-    with open(path, "r") as f:
-        test_data = json.load(f)
-
-    # Load input frames
-    if "input_frames" not in test_data:
-        raise ValueError("Test file must contain 'input_frames'")
-
-    input_frames = [dict_to_frame(frame_dict) for frame_dict in test_data["input_frames"]]
-
-    # Load expected output (optional)
-    expected_output = test_data.get("expected_output", None)
-
-    # Run the test
-    # Note: run_test() only collects frames if expected_down_frames is provided,
-    # so we need to manually collect from the pipeline ourselves
-    import asyncio
-    from pipecat.frames.frames import EndFrame
-    from pipecat.processors.frame_processor import FrameDirection
-    from pipecat.tests.utils import QueuedFrameProcessor
-    from pipecat.pipeline.pipeline import Pipeline
-    from pipecat.pipeline.task import PipelineTask, PipelineParams
-    from pipecat.pipeline.runner import PipelineRunner
-
-    # Set up the test pipeline manually
-    received_down = asyncio.Queue()
-    received_up = asyncio.Queue()
-    source = QueuedFrameProcessor(
-        queue=received_up,
-        queue_direction=FrameDirection.UPSTREAM,
-        ignore_start=True,
-    )
-    sink = QueuedFrameProcessor(
-        queue=received_down,
-        queue_direction=FrameDirection.DOWNSTREAM,
-        ignore_start=True,
-    )
-
-    pipeline = Pipeline([source, processor, sink])
-    task = PipelineTask(
-        pipeline,
-        params=PipelineParams(),
-        observers=[],
-        cancel_on_idle_timeout=False,
-    )
-
-    async def push_frames():
-        await asyncio.sleep(0.01)
-        for frame in input_frames:
-            await task.queue_frame(frame)
-        await task.queue_frame(EndFrame())
-
-    runner = PipelineRunner()
-    await asyncio.gather(runner.run(task), push_frames())
-
-    # Collect all frames from the downstream queue
-    downstream_frames = []
-    while not received_down.empty():
-        frame = await received_down.get()
-        if not isinstance(frame, EndFrame):
-            downstream_frames.append(frame)
-
-    # Validate if expected_output is provided
-    passed = None
-    if expected_output is not None:
-        passed = _validate_output(downstream_frames, expected_output)
-
-    return downstream_frames, expected_output, passed
-
-
-def _validate_output(actual_frames: List[Frame], expected_output: List[Dict[str, Any]]) -> bool:
-    """Validate actual output frames against expected output.
-
-    Args:
-        actual_frames: List of frames that were actually output
-        expected_output: List of expected frame specifications
-
-    Returns:
-        True if validation passed, False otherwise
-    """
-    if len(actual_frames) != len(expected_output):
-        return False
-
-    for actual, expected in zip(actual_frames, expected_output):
-        # Check frame type
-        if "type" not in expected:
-            return False
-
-        expected_type = expected["type"]
-        if actual.__class__.__name__ != expected_type:
-            return False
-
-        # Check specific fields if provided
-        for field_name, expected_value in expected.items():
-            if field_name == "type":
-                continue
-
-            if not hasattr(actual, field_name):
-                return False
-
-            actual_value = getattr(actual, field_name)
-
-            # Special handling for different types
-            if isinstance(expected_value, str) and isinstance(actual_value, str):
-                # For string fields, support partial matching with "contains"
-                if field_name.endswith("_contains"):
-                    base_field = field_name.replace("_contains", "")
-                    if hasattr(actual, base_field):
-                        actual_text = getattr(actual, base_field)
-                        if expected_value not in actual_text:
-                            return False
-                elif actual_value != expected_value:
-                    return False
-            elif actual_value != expected_value:
-                return False
-
-    return True
--- a/tests/test_service_switcher.py
+++ b/tests/test_service_switcher.py
@@ -7,12 +7,10 @@
 """Unit tests for ServiceSwitcher and related components."""

 import unittest
-from dataclasses import dataclass

 from pipecat.frames.frames import (
    Frame,
    ManuallySwitchServiceFrame,
-    SystemFrame,
    TextFrame,
 )
 from pipecat.pipeline.pipeline import Pipeline
@@ -54,13 +52,6 @@ class MockFrameProcessor(FrameProcessor):
        self.frame_count = 0


-@dataclass
-class DummySystemFrame(SystemFrame):
-    """A dummy system frame for testing purposes."""
-
-    text: str = ""
-
-
 class TestServiceSwitcherStrategyManual(unittest.IsolatedAsyncioTestCase):
    """Test cases for ServiceSwitcherStrategyManual."""

@@ -149,22 +140,14 @@ class TestServiceSwitcher(unittest.IsolatedAsyncioTestCase):
        # Send some test frames
        frames_to_send = [
            TextFrame(text="Hello 1"),
-            DummySystemFrame(text="System Message 1"),
            TextFrame(text="Hello 2"),
-            DummySystemFrame(text="System Message 2"),
            TextFrame(text="Hello 3"),
        ]

        await run_test(
            switcher,
            frames_to_send=frames_to_send,
-            expected_down_frames=[
-                DummySystemFrame,
-                DummySystemFrame,
-                TextFrame,
-                TextFrame,
-                TextFrame,
-            ],
+            expected_down_frames=[TextFrame, TextFrame, TextFrame],
            expected_up_frames=[],  # Expect no error frames
        )

@@ -173,13 +156,7 @@ class TestServiceSwitcher(unittest.IsolatedAsyncioTestCase):
        text_frames = [f for f in self.service1.processed_frames if isinstance(f, TextFrame)]
        self.assertEqual(len(text_frames), 3)

-        # Only service1 should have processed the system frames
-        system_frames = [
-            f for f in self.service1.processed_frames if isinstance(f, DummySystemFrame)
-        ]
-        self.assertEqual(len(system_frames), 2)
-
-        # Check that other services don't receive text frames (they still get StartFrame/EndFrame)
+        # Check that other services don't receive text frames (they might get StartFrame/EndFrame)
        service2_text_frames = [
            f for f in self.service2.processed_frames if isinstance(f, TextFrame)
        ]
@@ -189,24 +166,10 @@ class TestServiceSwitcher(unittest.IsolatedAsyncioTestCase):
        self.assertEqual(len(service2_text_frames), 0)
        self.assertEqual(len(service3_text_frames), 0)

-        # Check that other services don't receive dummy system frames (they still get StartFrame/EndFrame)
-        service2_system_frames = [
-            f for f in self.service2.processed_frames if isinstance(f, DummySystemFrame)
-        ]
-        service3_system_frames = [
-            f for f in self.service3.processed_frames if isinstance(f, DummySystemFrame)
-        ]
-        self.assertEqual(len(service2_system_frames), 0)
-        self.assertEqual(len(service3_system_frames), 0)
-
        # Verify the actual text frames processed
        for i, frame in enumerate(text_frames):
            self.assertEqual(frame.text, f"Hello {i + 1}")

-        # Verify the actual system frames processed
-        for i, frame in enumerate(system_frames):
-            self.assertEqual(frame.text, f"System Message {i + 1}")
-
    async def test_service_switching(self):
        """Test that after service switching using ManuallySwitchServiceFrame, the new active service receives frames while others don't."""
        switcher = ServiceSwitcher(self.services, ServiceSwitcherStrategyManual)
--- a/uv.lock
+++ b/uv.lock
@@ -410,16 +410,16 @@ wheels = [

 [[package]]
 name = "aws-sdk-bedrock-runtime"
-version = "0.1.1"
+version = "0.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "smithy-aws-core", extra = ["eventstream", "json"], marker = "python_full_version >= '3.12'" },
    { name = "smithy-core", marker = "python_full_version >= '3.12'" },
    { name = "smithy-http", extra = ["awscrt"], marker = "python_full_version >= '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1d/78/48574454b3cac869df67665e4a403ebfc3abfcfba2c2ff01ccfd67d55f8f/aws_sdk_bedrock_runtime-0.1.1.tar.gz", hash = "sha256:c896f99e675c3a1ab600633a07b785f3dc9fe8ab94f640b1f992b63da2dfc784", size = 82446, upload-time = "2025-10-21T20:25:25.845Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/e1/39971b907c83a7525bab112c9b395e1bb6d4bc23bc1712d6d7a050662217/aws_sdk_bedrock_runtime-0.1.0.tar.gz", hash = "sha256:bd062de5a48404f64e1dfe6fb8841fbbf68e8f1798c357d14eb427274cb96a2b", size = 85419, upload-time = "2025-09-29T19:40:01.855Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/83/07/62c0b70223d178c138f29124ac2f7973a6ba803abc7735b6a01a85217f3d/aws_sdk_bedrock_runtime-0.1.1-py3-none-any.whl", hash = "sha256:c0336b377b2112cf88197d3d44302fbeb3efb1101989fa49ae55e78f49cfe345", size = 74954, upload-time = "2025-10-21T20:25:24.973Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e1/5b36bffe85010cdcd44730d1c2d5244653d57c002f440141d7fc3b9f1347/aws_sdk_bedrock_runtime-0.1.0-py3-none-any.whl", hash = "sha256:aac6ff47069d456ca5e23083d96a01e3e0cbc215414e6753c289d7d9efef3335", size = 78853, upload-time = "2025-09-29T19:40:00.341Z" },
 ]

 [[package]]
@@ -433,31 +433,31 @@ wheels = [

 [[package]]
 name = "awscrt"
-version = "0.28.2"
+version = "0.28.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d4/1b/a885a699217967c3ff0e1c49ac5b1e2a050d1a8b87d1e85e958a56e3d3f5/awscrt-0.28.2.tar.gz", hash = "sha256:9715a888f2042e710dc8aeb355963a29b77e7a4cc25a14659cebd21a5fa476c1", size = 37894849, upload-time = "2025-10-14T19:06:16.867Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a0/1c/5c9e6a7375c2a1355aadeb2d06c96c95934ec37ff29ebaab2919f59c3ff1/awscrt-0.28.1.tar.gz", hash = "sha256:70a28fd6ff3e0abb7854ea8a9133bc9e5de681a0d9bdbd8a599a23d13a448685", size = 37956730, upload-time = "2025-09-19T00:58:31.564Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/b4/1a566e493bdfa6e918ba78bcd2e45dda99a25407a4fd974db2666228d154/awscrt-0.28.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:bec19c0dd780293a26c809aabb9f7675b28cb3a1bf05b4a5bc9f28d5ced75a81", size = 3380735, upload-time = "2025-10-14T19:05:16.58Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/53/6602a87aead1d413c7bd77d059b301745146635cda99ee2a61ec0d23691e/awscrt-0.28.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:01f33076759ba6285f25ccc6016355607df2e715d0bab3a1ef2416b87a6c3ade", size = 3827084, upload-time = "2025-10-14T19:05:19.335Z" },
-    { url = "https://files.pythonhosted.org/packages/d8/62/61fe39ae5950ad00e10dcbf6e4f4f344dc93957757160c0000390331a11b/awscrt-0.28.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b5c807b9972795ce54c05aea6918c60983c51d879ebbff7a67adb8b0d28a121", size = 4092678, upload-time = "2025-10-14T19:05:20.8Z" },
-    { url = "https://files.pythonhosted.org/packages/25/7d/e38f18cfb203e8f09842c0e3f422992887ce285ecc3bf18816d559a13c80/awscrt-0.28.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bf4ff9c8c6a233246320c2d41d939b6e25cdae97728d827186e4771a9edda688", size = 3749978, upload-time = "2025-10-14T19:05:22.16Z" },
-    { url = "https://files.pythonhosted.org/packages/16/6f/e8a3c0daed8f7b60c76fc2721bd4e83580ddecace24e0cb0ebb99564f699/awscrt-0.28.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0c738b83b66d1a8b43089556247fbe4adf2b73d610c7938d3bae1718a0fe8b1d", size = 3977237, upload-time = "2025-10-14T19:05:23.368Z" },
-    { url = "https://files.pythonhosted.org/packages/92/3d/8400203f02dd924bcc8255703179b0c26efd03c84f838db6f026fcef9ba6/awscrt-0.28.2-cp310-cp310-win32.whl", hash = "sha256:23c30004c736a2f826a32c9720f1ccf71e8e4deb8535da5915d6073604853098", size = 3919413, upload-time = "2025-10-14T19:05:24.477Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/5e/b5ccf377880a70425b100f1e5f5ba516ff75e291585b3dc129239fbd1ec3/awscrt-0.28.2-cp310-cp310-win_amd64.whl", hash = "sha256:859ae8a195d51f15b631147d6792953a563bfe0a1cc7a75b6750977634de54b8", size = 4056024, upload-time = "2025-10-14T19:05:25.956Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/79/94e9f0ee7c60ec6233c7ad6293589c56d5145172e49eb5328eda37d3fdd1/awscrt-0.28.2-cp311-abi3-macosx_10_15_universal2.whl", hash = "sha256:025eab99b58586d8c95f8fafe1f4695ad477eda20d1207240ee4f8ee79742059", size = 3381061, upload-time = "2025-10-14T19:05:27.187Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/b8/0da80dd58682ddf3ec204e877d5891198654647c085e65b6b8eacd214edb/awscrt-0.28.2-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e5c18d035d6cd92228e1db2f043517c1bcf9e0f6430c0af60cc34257dcca092c", size = 3788011, upload-time = "2025-10-14T19:05:28.768Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/d2/f51cf4364364399fe90d557e2fed14c1f114720191a5825898b1242bd607/awscrt-0.28.2-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c75f077e90d0220a49b75a9bca914e5aa1a3c8f28af6bce4d0332be0b98dd3cb", size = 4055226, upload-time = "2025-10-14T19:05:30.054Z" },
-    { url = "https://files.pythonhosted.org/packages/41/47/0fde8738a8c76de278ce431d8468ef18aeaca424329decca9ad5092df812/awscrt-0.28.2-cp311-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:1432c5c59a7e36b33eb2746cfbf30058f19ed43f2c117863897681f70bc246ba", size = 3692839, upload-time = "2025-10-14T19:05:31.471Z" },
-    { url = "https://files.pythonhosted.org/packages/18/25/cb3762f6b47fe503eea7f337eca7cfd044ab28bcc2452fbf298c6492ec8b/awscrt-0.28.2-cp311-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f96703c30b22ba1e43e1bb2fe996ac7af513bea411c54dbf09a3a1af329b9a76", size = 3918023, upload-time = "2025-10-14T19:05:33.162Z" },
-    { url = "https://files.pythonhosted.org/packages/95/0a/0b609acd45dbb83c04c7ecb8c7c789f5c15bbdd422129360bde093bc4a99/awscrt-0.28.2-cp311-abi3-win32.whl", hash = "sha256:3e94f63497b454d30892d7a7ce917a451c6f33590964d3a475d93f93b20083b6", size = 3917048, upload-time = "2025-10-14T19:05:34.745Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/38/bf33abd6d09c8572f8e09488db2b0a60124767d7f5d6d9a33cf8b051b7af/awscrt-0.28.2-cp311-abi3-win_amd64.whl", hash = "sha256:3e094772b1f6fd0f8c5f7cf37655d0984739f99493f66f534979a2a7bb7fc9f6", size = 4052877, upload-time = "2025-10-14T19:05:36.01Z" },
-    { url = "https://files.pythonhosted.org/packages/10/71/4be198e472d95702434cee1f9dd889c56e22bea8554b466fad754148fd24/awscrt-0.28.2-cp313-abi3-macosx_10_15_universal2.whl", hash = "sha256:5fda9e7d0eb800491fadebe2b6c2560ac2f5742b60f4106440dca4b49da7fb03", size = 3379585, upload-time = "2025-10-14T19:05:37.225Z" },
-    { url = "https://files.pythonhosted.org/packages/43/09/77084249d07dca71352341ad3fbcfa75deaccf25bd65f9fdbb36ce1f978b/awscrt-0.28.2-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:994a795bdc83344922a15891abb30155ec292093e856eef3929dd63dd6cadaca", size = 3779843, upload-time = "2025-10-14T19:05:38.774Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/bb/fcee9365e58e5860582398317571a9a5517da258cd81c3d987b9882f61d4/awscrt-0.28.2-cp313-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28537c4517168927ef74aa007a2e0c9f436921227934d82da31e9a1cec7e0c4a", size = 4049154, upload-time = "2025-10-14T19:05:40.301Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/8e/ac92b2707dbe05e56d0dd5af73cb4e07a3da4aee66936071123966523759/awscrt-0.28.2-cp313-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:b9fc6be63832da3ff244d56c7d9a43326d89d79e68162419c35f33e6ad033be0", size = 3683672, upload-time = "2025-10-14T19:05:41.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/d0/15308ec37e762691f5d1871b0f1a6e462da8e421c6c38d6724e3cf0994b2/awscrt-0.28.2-cp313-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:efb57103a368de1d33148cb70a382c4f82ac376c744de9484e0f621cef8313f3", size = 3912823, upload-time = "2025-10-14T19:05:43.781Z" },
-    { url = "https://files.pythonhosted.org/packages/bc/cd/7693b1d72069908b7a3ee30e4ef2b5fc8f54948a96397729277cb0b0c7b4/awscrt-0.28.2-cp313-abi3-win32.whl", hash = "sha256:594dc61f4f0c1c9fb7292364d25c21810b3608cd67c0de78a032ad48f7bfd88c", size = 3911514, upload-time = "2025-10-14T19:05:45.019Z" },
-    { url = "https://files.pythonhosted.org/packages/93/d6/5d8545c967690f03d55d44ed56ceff26d88363cd7d0435fd80a1c843ac2a/awscrt-0.28.2-cp313-abi3-win_amd64.whl", hash = "sha256:a17f0ab9dc5e5301da0fb00ccc4511a136d13abbd4a9564827547333fcd7ba16", size = 4047912, upload-time = "2025-10-14T19:05:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/75/dd62276f2907a9ffcf9f8f780c08ce9938bd0550a15c887db198b47f24d3/awscrt-0.28.1-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:47f885104065918d311102e2b08b943966717c0f3b0c5de5908d2fd08de32198", size = 3376838, upload-time = "2025-09-19T00:57:32.988Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/93/562709cdf13a7606548426ecc31326ba3f6839f91e98a1e9230208308afb/awscrt-0.28.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3df2316e77ad88c456b7eb2c9928007d379ed892154c1969d35b98653617e576", size = 3821522, upload-time = "2025-09-19T00:57:35.456Z" },
+    { url = "https://files.pythonhosted.org/packages/43/f0/6c6ff81f5a4c6d085eb450854149087bf9240c37c467c747521f47901b32/awscrt-0.28.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3a060d930939f142345f46a344e19ffc0dada657b04d02216b8adffba550c0a0", size = 4087344, upload-time = "2025-09-19T00:57:36.62Z" },
+    { url = "https://files.pythonhosted.org/packages/37/0a/71c097505add4ceea4ac05153311715acb7489cd82ec69db4570130f4698/awscrt-0.28.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:43f81ca6bfe85c38ad9765605aaaa646a1ed6fd7210dbedf67c113dd245f425e", size = 3745148, upload-time = "2025-09-19T00:57:38Z" },
+    { url = "https://files.pythonhosted.org/packages/79/1b/2b02b705a47b64e6c4d401087ddd30d4ad9af70172812ae8c62fb2b7a70c/awscrt-0.28.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fc8e2307d9dbe76842015a14701ff7e9cf2619d674621b2d55b769414e17b3fc", size = 3972439, upload-time = "2025-09-19T00:57:39.74Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/19/429c81c7a0d81a5edce9cc6d9a878c8b65d8b5b69fa5a2725a6e0b1380c1/awscrt-0.28.1-cp310-cp310-win32.whl", hash = "sha256:6e7b094587e5332d428300340dcc18794a1fcfa76d636f216fc0f5c8405ba604", size = 3915231, upload-time = "2025-09-19T00:57:41.096Z" },
+    { url = "https://files.pythonhosted.org/packages/83/81/769ad51fc6dcfd8bf9e0aa59c252013da0eb9e32c050ecbd1fc25f71689a/awscrt-0.28.1-cp310-cp310-win_amd64.whl", hash = "sha256:ac02f10f7384fdb68187f8d5d94743a271b16fa94be81481ce7684942f6a4b35", size = 4051668, upload-time = "2025-09-19T00:57:42.696Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/55/0ee537d146f24d6e76eaf02d462a83c572788233603bb9bda969fbf23307/awscrt-0.28.1-cp311-abi3-macosx_10_15_universal2.whl", hash = "sha256:cb36052f9aa34e77687a8037559bbea331fc9d5d77cd71ab0cf4e6d72af73f72", size = 3376673, upload-time = "2025-09-19T00:57:43.875Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/54/12700a4b9545680baa3e2d4d0e543bb4775a639df56ee51cbb29b71e0947/awscrt-0.28.1-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fc59829152a5806eb2708aca5c5084c11dd18ecbe765e03eb314d5a360eeaa62", size = 3782870, upload-time = "2025-09-19T00:57:45.737Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/e7/7b189ace9e187b9b55ed4a6ec9a451579b2f16bd01d402f79a19cc8e1603/awscrt-0.28.1-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d2f20bc774599b9d85ce66689415da529ddd1d2215da818e005deedc4688fe61", size = 4048789, upload-time = "2025-09-19T00:57:47.327Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/e0/2e5472019906dfcc5fadcdba4bad9e69dabb95bbc0c110cfe555ee8461dc/awscrt-0.28.1-cp311-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:491b8b9c73a288cfd5e0cbdac16aabb5313d5cfc33bbe461763a5ddc26624f70", size = 3687832, upload-time = "2025-09-19T00:57:48.563Z" },
+    { url = "https://files.pythonhosted.org/packages/71/f2/7e05d371bb888ee9f15e83d189287838f7b6ea40dfc91eacb3acd24b8529/awscrt-0.28.1-cp311-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:4c6c7125b7e9fcc999eb685d1cace8d4f2ffc63f8f3d8ef7f77e1a97d9552863", size = 3913378, upload-time = "2025-09-19T00:57:50.185Z" },
+    { url = "https://files.pythonhosted.org/packages/79/6b/a542a65a22edb85d64742970c21721e66e0f9f67911a11c7a5c3626a1b17/awscrt-0.28.1-cp311-abi3-win32.whl", hash = "sha256:1dcb33d7cf8f69881ac6ef75a5b9b40816be58678b1bb07ccbe0230281bdbc81", size = 3912809, upload-time = "2025-09-19T00:57:51.797Z" },
+    { url = "https://files.pythonhosted.org/packages/df/64/16cc8a0011e3ca5dda13605befa7e6db29bfb3073c67f6e8dad90be0a8ae/awscrt-0.28.1-cp311-abi3-win_amd64.whl", hash = "sha256:670caaf556876913bcfb9d8183d43d67a6c7b52998f2f398abd1c21632a006f8", size = 4048979, upload-time = "2025-09-19T00:57:53.061Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ac/debbd3a2f03c5953b56b1c3b321bab16293f857ea3005e3f7e5dded5e0b2/awscrt-0.28.1-cp313-abi3-macosx_10_15_universal2.whl", hash = "sha256:22311d25135b937ee5617e35a6554961727527dcfa3e06efdefe187a6abe65c4", size = 3375565, upload-time = "2025-09-19T00:57:54.598Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/4f/9388917ad45c043acd7c4ab2c28b9e2b5ddf29e21a82bfc01a7626c18c04/awscrt-0.28.1-cp313-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e58740cf0e41552fdf7909e10814b312ab090ebe54741354a61507e0c6d4ebfd", size = 3775366, upload-time = "2025-09-19T00:57:56.238Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/e3/3ef301cdef76b22ce14b041e04c6cf65ba4491d00e9f5b400c0699f6c63e/awscrt-0.28.1-cp313-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9e69f163a207a8b172abbfea1f51045301ed1ac8bbaf76958a6b5e81d72e5b89", size = 4043403, upload-time = "2025-09-19T00:57:57.4Z" },
+    { url = "https://files.pythonhosted.org/packages/60/9c/4f89922333724c4da851752549ca97dd147420734ef6c4ece56d5dd65e09/awscrt-0.28.1-cp313-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:592f4b234ecafa6cde86e55e42c4fe84c4e1ffe9fb11b0a8b8f0ffb8c62fa2cc", size = 3678742, upload-time = "2025-09-19T00:57:59.055Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/d4/adb97ba5f888ed201aa1f9e9f8d6cfc0dbaf80f0e937b3acb7411febdaa8/awscrt-0.28.1-cp313-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:b16321f1d2bf5b4991a213059c1b5dc07954edfc424d154b093824465ec94ce2", size = 3908438, upload-time = "2025-09-19T00:58:00.71Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ac/600ea0a6f4ba6543c50417c8e78b09f2cd73dd0f0d4c3e9e52220a8badbe/awscrt-0.28.1-cp313-abi3-win32.whl", hash = "sha256:3e0a23635aa75b4af163ff9bf5a0873928369b1ac32c8b1351741a95472ccf71", size = 3907625, upload-time = "2025-09-19T00:58:03.235Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/24/d22c7197b1e53c76b5eb71d640a4728b9b7621075d8dbcc054e16b5b98f0/awscrt-0.28.1-cp313-abi3-win_amd64.whl", hash = "sha256:9849c88ca0830396724acf988e2759895118fe7dd2a23dab21978c8600d01a11", size = 4043878, upload-time = "2025-09-19T00:58:04.595Z" },
 ]

 [[package]]
@@ -4633,7 +4633,7 @@ requires-dist = [
    { name = "aiortc", marker = "extra == 'webrtc'", specifier = ">=1.13.0,<2" },
    { name = "anthropic", marker = "extra == 'anthropic'", specifier = "~=0.49.0" },
    { name = "audioop-lts", marker = "python_full_version >= '3.13'", specifier = "~=0.2.1" },
-    { name = "aws-sdk-bedrock-runtime", marker = "python_full_version >= '3.12' and extra == 'aws-nova-sonic'", specifier = "~=0.1.1" },
+    { name = "aws-sdk-bedrock-runtime", marker = "python_full_version >= '3.12' and extra == 'aws-nova-sonic'", specifier = "~=0.1.0" },
    { name = "azure-cognitiveservices-speech", marker = "extra == 'azure'", specifier = "~=1.42.0" },
    { name = "cartesia", marker = "extra == 'cartesia'", specifier = "~=2.0.3" },
    { name = "coremltools", marker = "extra == 'local-smart-turn'", specifier = ">=8.0" },
@@ -6483,16 +6483,16 @@ wheels = [

 [[package]]
 name = "smithy-aws-core"
-version = "0.1.1"
+version = "0.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "aws-sdk-signers", marker = "python_full_version >= '3.12'" },
    { name = "smithy-core", marker = "python_full_version >= '3.12'" },
    { name = "smithy-http", marker = "python_full_version >= '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/56/d3/f847e0fd36b95aa36ce3a4c9ce1a08e16b2aa9a56b71714045c9c924e282/smithy_aws_core-0.1.1.tar.gz", hash = "sha256:78dfd7040fc2bc72b6af293096642fc9a7bfd2db28ddbdf7c4110535eab9d662", size = 11196, upload-time = "2025-10-21T20:21:18.648Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/e8/8cef48be92ed09a112c54747a4515313ba96e767e7e0118a769aeb147e07/smithy_aws_core-0.1.0.tar.gz", hash = "sha256:5f197b69ad1380e9118e1e3c9032e0e305525ef56fb4fc97dea6414281065526", size = 11135, upload-time = "2025-09-29T19:37:13.072Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/04/87cb06f0f6d664b5cffdef6d4042dd52c11c138436084d30ffdaa3543031/smithy_aws_core-0.1.1-py3-none-any.whl", hash = "sha256:0d1634f276c2999dc2a04fafef63b9d28309de50d939d1d49df952773a7063c4", size = 18963, upload-time = "2025-10-21T20:21:17.692Z" },
+    { url = "https://files.pythonhosted.org/packages/46/7e/6d05275646bc2cdf7b0749e9bd54958a4e808aafeee4d8ff2fdaa8233dc2/smithy_aws_core-0.1.0-py3-none-any.whl", hash = "sha256:a8cda4011562f45f1fc5957c3a981b6016d736178450e5f2a1586937632af487", size = 18959, upload-time = "2025-09-29T19:37:12.041Z" },
 ]

 [package.optional-dependencies]
@@ -6526,14 +6526,14 @@ wheels = [

 [[package]]
 name = "smithy-http"
-version = "0.2.0"
+version = "0.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
    { name = "smithy-core", marker = "python_full_version >= '3.12'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/3c/1c/44e99a7dfb8c39bf0c3d998accdf4573a7a3488863b90f21af260cec2d45/smithy_http-0.2.0.tar.gz", hash = "sha256:2382562fa9af326be455f14b18615f16ffe9db756e51b2a4ca0d23e1b881cff8", size = 26729, upload-time = "2025-10-21T20:21:06.146Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/62/5ba46c7432fbb0852acf8340402879ba53bb4c009b875e1b5b2e9df844ff/smithy_http-0.1.0.tar.gz", hash = "sha256:ed44552531f594e31101f7186c7b01b508ecd38a860b45390a1cce7da700df4b", size = 28269, upload-time = "2025-09-29T19:37:18.629Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/e2/d475fad81ac74ec0e145cb6d72afe5ecde4e2358bd632c2fd5d3f4bc87dc/smithy_http-0.2.0-py3-none-any.whl", hash = "sha256:49ee2402d7737798d70f99f491fbfb2a5767283ae562e21b6f86e3fd14f3e3e0", size = 37328, upload-time = "2025-10-21T20:21:05.362Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/23/d18076ea45b3000c5e9eb8ebd75a4ea1b65b5c59e5c2080a119e2679dfba/smithy_http-0.1.0-py3-none-any.whl", hash = "sha256:7657aaf4b9e025cb9d317406f417b49cf19fba9d1b2ab4f5e6d9dc5a2dd7cdba", size = 38995, upload-time = "2025-09-29T19:37:17.506Z" },
 ]

 [package.optional-dependencies]