livekit-plugins-hume 1.0.22__tar.gz → 1.3.3__tar.gz

{livekit_plugins_hume-1.0.22 → livekit_plugins_hume-1.3.3}/.gitignore

@@ -146,6 +146,9 @@ venv.bak/
 .dmypy.json
 dmypy.json
 
+# trunk
+.trunk/
+
 # Pyre type checker
 .pyre/
 
@@ -166,4 +169,11 @@ node_modules
 
 credentials.json
 pyrightconfig.json
-docs/
+docs/
+
+# Database files
+*.db
+
+
+# Examples for development
+examples/dev/*

{livekit_plugins_hume-1.0.22 → livekit_plugins_hume-1.3.3}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-hume
-Version: 1.0.22
+Version: 1.3.3
 Summary: Hume TTS plugin for LiveKit agents
 Project-URL: Documentation, https://docs.livekit.io
 Project-URL: Website, https://livekit.io/
 Project-URL: Source, https://github.com/livekit/agents
 Author-email: LiveKit <info@livekit.io>
 License-Expression: Apache-2.0
-Keywords: Hume,HumeAI,Octave,audio,livekit,realtime,webrtc
+Keywords: Hume,HumeAI,Octave,ai,audio,livekit,realtime,video,voice
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -17,8 +17,7 @@ Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.9.0
 Requires-Dist: aiohttp>=3.8.0
-Requires-Dist: hume>=0.8.3
-Requires-Dist: livekit-agents>=1.0.22
+Requires-Dist: livekit-agents>=1.3.3
 Description-Content-Type: text/markdown
 
 # Hume AI TTS plugin for LiveKit Agents

{livekit_plugins_hume-1.0.22 → livekit_plugins_hume-1.3.3}/livekit/plugins/hume/__init__.py

@@ -19,24 +19,26 @@ See https://docs.livekit.io/agents/integrations/tts/hume/ for more information.
 
 from __future__ import annotations
 
-__version__ = "1.0.0"
-
-# make imports available
-from hume.tts import (
-    Format,
-    PostedContext,
-    PostedUtteranceVoice,
-)
 from livekit.agents import Plugin
 
-from .tts import TTS
+from .tts import (
+    TTS,
+    AudioFormat,
+    Utterance,
+    VoiceById,
+    VoiceByName,
+    VoiceProvider,
+)
+from .version import __version__
 
-# all exports
 __all__ = [
     "TTS",
-    "Format",
-    "PostedContext",
-    "PostedUtteranceVoice",
+    "AudioFormat",
+    "ModelVersion",
+    "VoiceById",
+    "VoiceByName",
+    "VoiceProvider",
+    "Utterance",
 ]
 
 
@@ -55,12 +57,3 @@ __pdoc__ = {}
 
 for n in NOT_IN_ALL:
     __pdoc__[n] = False
-
-# Cleanup docs of unexported modules
-_module = dir()
-NOT_IN_ALL = [m for m in _module if m not in __all__]
-
-__pdoc__ = {}
-
-for n in NOT_IN_ALL:
-    __pdoc__[n] = False

livekit_plugins_hume-1.3.3/livekit/plugins/hume/tts.py

@@ -0,0 +1,304 @@
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+from dataclasses import dataclass, replace
+from enum import Enum
+from typing import Any, Literal, TypedDict
+
+import aiohttp
+
+from livekit.agents import (
+    APIConnectionError,
+    APIConnectOptions,
+    APIError,
+    APITimeoutError,
+    tts,
+    utils,
+)
+from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, NOT_GIVEN, NotGivenOr
+from livekit.agents.utils import is_given
+
+from .version import __version__
+
+
+class VoiceById(TypedDict, total=False):
+    id: str
+    provider: VoiceProvider | None
+
+
+class VoiceByName(TypedDict, total=False):
+    name: str
+    provider: VoiceProvider | None
+
+
+class Utterance(TypedDict, total=False):
+    """Utterance for TTS synthesis."""
+
+    text: str
+    description: str | None
+    speed: float | None
+    voice: VoiceById | VoiceByName | None
+    trailing_silence: float | None
+
+
+class VoiceProvider(str, Enum):
+    """Voice provider for the voice library."""
+
+    hume = "HUME_AI"
+    custom = "CUSTOM_VOICE"
+
+
+class AudioFormat(str, Enum):
+    """Audio format for the synthesized speech."""
+
+    mp3 = "mp3"
+    wav = "wav"
+    pcm = "pcm"
+
+
+ModelVersion = Literal["1", "2"]
+
+
+DEFAULT_HEADERS = {
+    "X-Hume-Client-Name": "livekit",
+    "X-Hume-Client-Version": __version__,
+}
+API_AUTH_HEADER = "X-Hume-Api-Key"
+STREAM_PATH = "/v0/tts/stream/json"
+DEFAULT_BASE_URL = "https://api.hume.ai"
+SUPPORTED_SAMPLE_RATE = 48000
+DEFAULT_VOICE = VoiceByName(name="Male English Actor", provider=VoiceProvider.hume)
+
+
+@dataclass
+class _TTSOptions:
+    api_key: str
+    base_url: str
+    voice: VoiceById | VoiceByName | None
+    model_version: ModelVersion | None
+    description: str | None
+    speed: float | None
+    trailing_silence: float | None
+    context: str | list[Utterance] | None
+    instant_mode: bool | None
+    audio_format: AudioFormat
+
+    def http_url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+
+
+class TTS(tts.TTS):
+    def __init__(
+        self,
+        *,
+        api_key: str | None = None,
+        voice: VoiceById | VoiceByName | None = DEFAULT_VOICE,
+        model_version: ModelVersion | None = "1",
+        description: str | None = None,
+        speed: float | None = None,
+        trailing_silence: float | None = None,
+        context: str | list[Utterance] | None = None,
+        instant_mode: NotGivenOr[bool] = NOT_GIVEN,
+        audio_format: AudioFormat = AudioFormat.mp3,
+        base_url: str = DEFAULT_BASE_URL,
+        http_session: aiohttp.ClientSession | None = None,
+    ):
+        """Initialize the Hume AI TTS client. Options will be used for all future synthesis
+        (until updated with update_options).
+
+        Args:
+            api_key: Hume AI API key. If not provided, will look for HUME_API_KEY environment
+                variable.
+            voice: A voice from the voice library specified by name or id.
+            model_version: Specifies which version of Octave to use. See Hume's documentation for
+                details on model version differences: https://dev.hume.ai/docs/text-to-speech-tts/overview.
+            description: Natural language instructions describing how the synthesized speech
+                should sound (≤1000 characters).
+            speed: Speed multiplier for the synthesized speech (≥0.5, ≤2.0, default: 1.0).
+            trailing_silence: Duration of trailing silence (in seconds) to add to each utterance
+                (≥0, ≤5.0, default: 0.35).
+            context: Optional context for synthesis, either as text or list of utterances.
+            instant_mode: Whether to use instant mode. Defaults to True if voice specified,
+                False otherwise. Requires a voice to be specified when enabled.
+            audio_format: Output audio format (mp3, wav, or pcm). Defaults to mp3.
+            base_url: Base URL for Hume AI API. Defaults to https://api.hume.ai
+            http_session: Optional aiohttp ClientSession to use for requests.
+        """
+        super().__init__(
+            capabilities=tts.TTSCapabilities(streaming=False),
+            sample_rate=SUPPORTED_SAMPLE_RATE,
+            num_channels=1,
+        )
+        key = api_key or os.environ.get("HUME_API_KEY")
+        if not key:
+            raise ValueError("Hume API key is required via api_key or HUME_API_KEY env var")
+
+        has_voice = voice is not None
+
+        # Default instant_mode is True if a voice is specified, otherwise False
+        # (Hume API requires a voice for instant mode)
+        if not is_given(instant_mode):
+            resolved_instant_mode = has_voice
+        elif instant_mode and not has_voice:
+            raise ValueError("Hume TTS: instant_mode cannot be enabled without specifying a voice")
+        else:
+            resolved_instant_mode = instant_mode
+
+        self._opts = _TTSOptions(
+            api_key=key,
+            voice=voice,
+            model_version=model_version,
+            description=description,
+            speed=speed,
+            trailing_silence=trailing_silence,
+            context=context,
+            instant_mode=resolved_instant_mode,
+            audio_format=audio_format,
+            base_url=base_url,
+        )
+        self._session = http_session
+
+    @property
+    def model(self) -> str:
+        return "Octave"
+
+    @property
+    def provider(self) -> str:
+        return "Hume"
+
+    def _ensure_session(self) -> aiohttp.ClientSession:
+        if not self._session:
+            self._session = utils.http_context.http_session()
+
+        return self._session
+
+    def update_options(
+        self,
+        *,
+        description: NotGivenOr[str | None] = NOT_GIVEN,
+        speed: NotGivenOr[float | None] = NOT_GIVEN,
+        voice: NotGivenOr[VoiceById | VoiceByName | None] = NOT_GIVEN,
+        trailing_silence: NotGivenOr[float | None] = NOT_GIVEN,
+        context: NotGivenOr[str | list[Utterance] | None] = NOT_GIVEN,
+        instant_mode: NotGivenOr[bool] = NOT_GIVEN,
+        audio_format: NotGivenOr[AudioFormat] = NOT_GIVEN,
+    ) -> None:
+        """Update TTS options used for all future synthesis (until updated again)
+
+        Args:
+            voice: A voice from the voice library specified by name or id.
+            description: Natural language instructions describing how the synthesized speech
+                should sound (≤1000 characters).
+            speed: Speed multiplier for the synthesized speech (≥0.5, ≤2.0, default: 1.0).
+            trailing_silence: Duration of trailing silence (in seconds) to add to each utterance.
+            context: Optional context for synthesis, either as text or list of utterances.
+            instant_mode: Whether to use instant mode.
+            audio_format: Output audio format (mp3, wav, or pcm).
+        """
+        if is_given(description):
+            self._opts.description = description
+        if is_given(speed):
+            self._opts.speed = speed
+        if is_given(voice):
+            self._opts.voice = voice  # type: ignore
+        if is_given(trailing_silence):
+            self._opts.trailing_silence = trailing_silence
+        if is_given(context):
+            self._opts.context = context  # type: ignore
+        if is_given(instant_mode):
+            self._opts.instant_mode = instant_mode
+        if is_given(audio_format):
+            self._opts.audio_format = audio_format
+
+    def synthesize(
+        self, text: str, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
+    ) -> tts.ChunkedStream:
+        return ChunkedStream(tts=self, input_text=text, conn_options=conn_options)
+
+
+class ChunkedStream(tts.ChunkedStream):
+    def __init__(self, *, tts: TTS, input_text: str, conn_options: APIConnectOptions) -> None:
+        super().__init__(tts=tts, input_text=input_text, conn_options=conn_options)
+        self._tts: TTS = tts
+        self._opts = replace(tts._opts)
+
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        utterance: Utterance = {
+            "text": self._input_text,
+        }
+
+        if self._opts.voice:
+            utterance["voice"] = self._opts.voice
+        if self._opts.description:
+            utterance["description"] = self._opts.description
+        if self._opts.speed:
+            utterance["speed"] = self._opts.speed
+        if self._opts.trailing_silence:
+            utterance["trailing_silence"] = self._opts.trailing_silence
+
+        payload: dict[str, Any] = {
+            "utterances": [utterance],
+            "version": self._opts.model_version,
+            "strip_headers": True,
+            "instant_mode": self._opts.instant_mode,
+            "format": {"type": self._opts.audio_format.value},
+        }
+        if isinstance(self._opts.context, str):
+            payload["context"] = {"generation_id": self._opts.context}
+        elif isinstance(self._opts.context, list):
+            payload["context"] = {"utterances": self._opts.context}
+
+        try:
+            async with self._tts._ensure_session().post(
+                self._opts.http_url(STREAM_PATH),
+                headers={**DEFAULT_HEADERS, API_AUTH_HEADER: self._opts.api_key},
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=None, sock_connect=self._conn_options.timeout),
+                # large read_bufsize to avoid `ValueError: Chunk too big`
+                read_bufsize=10 * 1024 * 1024,
+            ) as resp:
+                resp.raise_for_status()
+
+                output_emitter.initialize(
+                    request_id=utils.shortuuid(),
+                    sample_rate=SUPPORTED_SAMPLE_RATE,
+                    num_channels=self._tts.num_channels,
+                    mime_type=f"audio/{self._opts.audio_format.value}",
+                )
+
+                async for raw_line in resp.content:
+                    line = raw_line.strip()
+                    if not line:
+                        continue
+
+                    data = json.loads(line.decode())
+                    if data.get("type") == "error":
+                        raise APIError(message=str(data))
+
+                    audio_b64 = data.get("audio")
+                    if audio_b64:
+                        output_emitter.push(base64.b64decode(audio_b64))
+
+                output_emitter.flush()
+
+        except asyncio.TimeoutError:
+            raise APITimeoutError() from None
+        except Exception as e:
+            raise APIConnectionError() from e

{livekit_plugins_hume-1.0.22 → livekit_plugins_hume-1.3.3}/livekit/plugins/hume/version.py

@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "1.0.22"
+__version__ = "1.3.3"

{livekit_plugins_hume-1.0.22 → livekit_plugins_hume-1.3.3}/pyproject.toml

@@ -12,7 +12,7 @@ requires-python = ">=3.9.0"
 authors = [
     {name = "LiveKit", email = "info@livekit.io"}
 ]
-keywords = ["webrtc", "realtime", "audio", "livekit", "HumeAI", "Hume", "Octave"]
+keywords = ["voice", "ai", "realtime", "audio", "video", "livekit", "HumeAI", "Hume", "Octave"]
 classifiers = [
     "Intended Audience :: Developers",
     "Topic :: Multimedia :: Sound/Audio",
@@ -24,8 +24,7 @@ classifiers = [
 ]
 dependencies = [
     "aiohttp>=3.8.0",
-    "livekit-agents>=1.0.22",
-    "hume>=0.8.3"
+    "livekit-agents>=1.3.3",
 ]
 
 [project.urls]

livekit_plugins_hume-1.0.22/livekit/plugins/hume/tts.py

@@ -1,283 +0,0 @@
-# Copyright 2023 LiveKit, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import os
-from dataclasses import dataclass
-
-import aiohttp
-
-from hume import AsyncHumeClient
-from hume.tts import Format, FormatWav, PostedContext, PostedUtterance, PostedUtteranceVoice
-from livekit.agents import (
-    APIConnectionError,
-    APIConnectOptions,
-    APITimeoutError,
-    tokenize,
-    tts,
-    utils,
-)
-from livekit.agents.types import (
-    DEFAULT_API_CONNECT_OPTIONS,
-    NOT_GIVEN,
-    NotGivenOr,
-)
-from livekit.agents.utils import is_given
-
-# Default audio settings
-DEFAULT_SAMPLE_RATE = 48000
-DEFAULT_NUM_CHANNELS = 1
-
-
-@dataclass
-class _TTSOptions:
-    """TTS options for Hume API"""
-
-    api_key: str
-    voice: PostedUtteranceVoice | None
-    description: str | None
-    speed: float | None
-    context: PostedContext | None
-    format: Format
-    strip_headers: bool
-    instant_mode: bool
-    word_tokenizer: tokenize.WordTokenizer
-
-
-class TTS(tts.TTS):
-    def __init__(
-        self,
-        *,
-        voice: NotGivenOr[PostedUtteranceVoice] = NOT_GIVEN,
-        description: NotGivenOr[str] = NOT_GIVEN,
-        speed: NotGivenOr[float] = NOT_GIVEN,
-        context: NotGivenOr[PostedContext] = NOT_GIVEN,
-        format: NotGivenOr[Format] = NOT_GIVEN,
-        instant_mode: bool = False,
-        strip_headers: bool = True,
-        api_key: NotGivenOr[str] = NOT_GIVEN,
-        word_tokenizer: tokenize.WordTokenizer | None = None,
-        http_session: aiohttp.ClientSession | None = None,
-    ) -> None:
-        """Initialize the Hume TTS client.
-
-        See https://dev.hume.ai/reference/text-to-speech-tts/synthesize-json-streaming for API doc
-
-        Args:
-            voice (NotGivenOr[PostedUtteranceVoice]): The voice, specified by name or id, to be
-                used. When no voice is specified, a novel voice will be generated based on the
-                text and optionally provided description.
-            description (NotGivenOr[str]): Natural language instructions describing how the
-                synthesized speech should sound, including but not limited to tone, intonation,
-                pacing, and accent. If a Voice is specified in the request, this description
-                serves as acting instructions. If no Voice is specified, a new voice is generated
-                based on this description.
-            speed: (NotGivenOr[float]): Adjusts the relative speaking rate on a non-linear scale
-                from 0.25 (much slower) to 3.0 (much faster), where 1.0 represents normal speaking
-                pace.
-            context (NotGivenOr[PostedContext]): Utterances to use as context for generating
-                consistent speech style and prosody across multiple requests.
-            format (NotGivenOr[Format]): Specifies the output audio file format (WAV, MP3 or PCM).
-                Defaults to WAV format.
-            instant_mode (bool): Enables ultra-low latency streaming, reducing time to first chunk.
-                Recommended for real-time applications. Only for streaming endpoints.
-                With this enabled, requests incur 10% higher cost. Defaults to False.
-            strip_headers (bool): If enabled, the audio for all the chunks of a generation.
-                Once concatenated together, will constitute a single audio file.
-                If disabled, each chunk’s audio will be its own audio file, each with its headers.
-            api_key (NotGivenOr[str]): Hume API key for authentication. If not provided,
-                will attempt to read from HUME_API_KEY environment variable.
-            word_tokenizer (tokenize.WordTokenizer | None): Custom word tokenizer to use for text.
-                If None, a basic word tokenizer will be used.
-            http_session (aiohttp.ClientSession | None): Optional HTTP session for API requests.
-                If None, a new session will be created.
-        """
-
-        super().__init__(
-            capabilities=tts.TTSCapabilities(
-                streaming=False,
-            ),
-            sample_rate=DEFAULT_SAMPLE_RATE,
-            num_channels=DEFAULT_NUM_CHANNELS,
-        )
-
-        self._api_key = api_key if is_given(api_key) else os.environ.get("HUME_API_KEY")
-        if not self._api_key:
-            raise ValueError(
-                "Hume API key is required, either as argument or set HUME_API_KEY env variable"
-            )
-
-        if not word_tokenizer:
-            word_tokenizer = tokenize.basic.WordTokenizer(ignore_punctuation=False)
-
-        self._opts = _TTSOptions(
-            voice=voice if is_given(voice) else None,
-            description=description if is_given(description) else None,
-            speed=speed if is_given(speed) else None,
-            context=context if is_given(context) else None,
-            format=format if is_given(format) else FormatWav(),
-            api_key=self._api_key,
-            strip_headers=strip_headers,
-            instant_mode=instant_mode,
-            word_tokenizer=word_tokenizer,
-        )
-
-        self._client = AsyncHumeClient(api_key=self._api_key)
-        self._session = http_session
-
-    def _ensure_session(self) -> aiohttp.ClientSession:
-        if not self._session:
-            self._session = utils.http_context.http_session()
-        return self._session
-
-    def update_options(
-        self,
-        *,
-        voice: NotGivenOr[PostedUtteranceVoice] = NOT_GIVEN,
-        description: NotGivenOr[str] = NOT_GIVEN,
-        speed: NotGivenOr[float] = NOT_GIVEN,
-        context: NotGivenOr[PostedContext] = NOT_GIVEN,
-        format: NotGivenOr[Format] = NOT_GIVEN,
-        instant_mode: NotGivenOr[bool] = NOT_GIVEN,
-        strip_headers: NotGivenOr[bool] = NOT_GIVEN,
-    ) -> None:
-        """Update TTS options for synthesizing speech.
-
-        Args:
-            voice (NotGivenOr[PostedUtteranceVoice]): The voice, specified by name or id, to be
-                used. When no voice is specified, a novel voice will be generated based on the
-                text and optionally provided description.
-            description (NotGivenOr[str]): Natural language instructions describing how the
-                synthesized speech should sound, including but not limited to tone, intonation,
-                pacing, and accent. If a Voice is specified in the request, this description
-                serves as acting instructions. If no Voice is specified, a new voice is generated
-                based on this description.
-            speed: (NotGivenOr[float]): Adjusts the relative speaking rate on a non-linear scale
-                from 0.25 (much slower) to 3.0 (much faster), where 1.0 represents normal speaking
-                pace.
-            context (Optional[PostedContext]): Utterances to use as context for generating
-                consistent speech style and prosody across multiple requests.
-            format (NotGivenOr[Format]): Specifies the output audio file format (WAV, MP3 or PCM).
-            instant_mode (NotGivenOr[bool]): Enables ultra-low latency streaming.
-                Reduces time to first audio chunk, recommended for real-time applications.
-                Note: Incurs 10% higher cost when enabled.
-            strip_headers (NotGivenOr[bool]): If enabled, the audio for the chunks of a generation.
-                Once concatenated together, will constitute a single audio file.
-                If disabled, each chunk’s audio will be its own audio file, each with its headers.
-        """
-
-        if is_given(voice):
-            self._opts.voice = voice
-        if is_given(description):
-            self._opts.description = description
-        if is_given(speed):
-            self._opts.speed = speed
-        if is_given(format):
-            self._opts.format = format
-        if is_given(context):
-            self._opts.context = context
-        if is_given(instant_mode):
-            self._opts.instant_mode = instant_mode
-        if is_given(strip_headers):
-            self._opts.strip_headers = strip_headers
-
-    def synthesize(
-        self,
-        text: str,
-        *,
-        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
-    ) -> ChunkedStream:
-        return ChunkedStream(
-            tts=self,
-            input_text=text,
-            conn_options=conn_options,
-            opts=self._opts,
-        )
-
-
-class ChunkedStream(tts.ChunkedStream):
-    """Stream for Hume TTS JSON streaming API."""
-
-    def __init__(
-        self,
-        *,
-        tts: TTS,
-        input_text: str,
-        opts: _TTSOptions,
-        conn_options: APIConnectOptions,
-    ) -> None:
-        super().__init__(tts=tts, input_text=input_text, conn_options=conn_options)
-        self._opts = opts
-        self._client = tts._client
-
-    async def _run(self) -> None:
-        request_id = utils.shortuuid()
-
-        decoder = utils.codecs.AudioStreamDecoder(
-            sample_rate=DEFAULT_SAMPLE_RATE,
-            num_channels=DEFAULT_NUM_CHANNELS,
-        )
-
-        decode_task: asyncio.Task | None = None
-
-        try:
-
-            async def _decode_loop():
-                utterance_options = {
-                    "voice": self._opts.voice,
-                    "description": self._opts.description,
-                    "speed": self._opts.speed,
-                }
-
-                utterance_kwargs = {
-                    "text": self._input_text,
-                    **{k: v for k, v in utterance_options.items() if v is not None},
-                }
-
-                try:
-                    utterance = PostedUtterance(**utterance_kwargs)
-
-                    async for chunk in self._client.tts.synthesize_json_streaming(
-                        utterances=[utterance],
-                        context=self._opts.context,
-                        format=self._opts.format,
-                        instant_mode=self._opts.instant_mode,
-                        strip_headers=self._opts.strip_headers,
-                    ):
-                        decoder.push(base64.b64decode(chunk.audio))
-
-                finally:
-                    decoder.end_input()
-
-            decode_task = asyncio.create_task(_decode_loop())
-            emitter = tts.SynthesizedAudioEmitter(
-                event_ch=self._event_ch,
-                request_id=request_id,
-            )
-            async for frame in decoder:
-                emitter.push(frame)
-
-            emitter.flush()
-
-        except asyncio.TimeoutError:
-            raise APITimeoutError() from None
-        except Exception as e:
-            raise APIConnectionError() from e
-        finally:
-            if decode_task:
-                await utils.aio.gracefully_cancel(decode_task)
-            await decoder.aclose()