livekit-plugins-tts-cache-router 0.1.0__py3-none-any.whl

livekit/plugins/tts_cache_router/__init__.py

@@ -0,0 +1,62 @@
+# Copyright 2026 Oggnai Technologies Private Limited
+#
+# 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.
+
+"""tts-cache-router plugin for LiveKit Agents.
+
+Serves repeated sentences from a per-account cache and synthesizes the rest at Sarvam, Raya or
+ElevenLabs with your own provider key. See https://docs.ttscacherouter.dev/livekit.
+"""
+
+from .providers import (
+    ElevenLabs,
+    PronunciationDictionaryLocator,
+    Raya,
+    Sarvam,
+    VoiceSettings,
+)
+from .tts import TTS, ChunkedStream, SynthesizeStream
+from .version import __version__
+
+__all__ = [
+    "TTS",
+    "ChunkedStream",
+    "SynthesizeStream",
+    "Sarvam",
+    "Raya",
+    "ElevenLabs",
+    "VoiceSettings",
+    "PronunciationDictionaryLocator",
+    "__version__",
+]
+
+from livekit.agents import Plugin
+
+from .log import logger
+
+
+class TTSCacheRouterPlugin(Plugin):
+    def __init__(self) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+
+
+Plugin.register_plugin(TTSCacheRouterPlugin())
+
+# 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/tts_cache_router/log.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("livekit.plugins.tts_cache_router")

livekit/plugins/tts_cache_router/providers.py

@@ -0,0 +1,319 @@
+# Copyright 2026 Oggnai Technologies Private Limited
+#
+# 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.
+
+"""The provider the router synthesizes with, in that provider's own parameter names."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from livekit.agents import LanguageCode
+
+SarvamModels = Literal["bulbul:v3", "bulbul:v4-flash"]
+RayaModels = Literal["m1", "standard"]
+ElevenLabsModels = Literal[
+    "eleven_flash_v2_5",
+    "eleven_turbo_v2_5",
+    "eleven_multilingual_v2",
+    "eleven_flash_v2",
+    "eleven_turbo_v2",
+    "eleven_v3",
+    "eleven_v3_conversational",
+    "eleven_v4",
+    "eleven_v4_turbo",
+]
+_ELEVENLABS_MODELS = ElevenLabsModels.__args__  # type: ignore[attr-defined]
+
+
+@dataclass(frozen=True)
+class Sarvam:
+    """Sarvam Bulbul. The router calls Sarvam with the Sarvam API key stored for your org in
+    the dashboard.
+
+    Args:
+        model: ``"bulbul:v3"`` or ``"bulbul:v4-flash"``.
+        speaker: Sarvam speaker id, e.g. ``"shubh"``. Must belong to ``model``.
+        language: Sarvam language code, e.g. ``"hi-IN"``.
+        pace: Speech speed, 0.5–2.0.
+        temperature: Sampling temperature, 0.01–1.0.
+        dict_id: Optional pronunciation dictionary id.
+        pitch: ``bulbul:v4-flash`` only: -0.5 (deeper) to 0.5 (higher); Sarvam's default is 0.
+        loudness: ``bulbul:v4-flash`` only: 0.1–2.5; Sarvam's default is 1.0.
+        enable_preprocessing: ``bulbul:v4-flash`` only: normalize numbers and English words in
+            the text before synthesis.
+        min_buffer_size: Characters Sarvam buffers before it starts synthesizing, 30–200.
+            Defaults to the least Sarvam allows.
+        max_chunk_length: The longest text Sarvam synthesizes in one piece, 50–500; it splits
+            longer sentences. Defaults to the most Sarvam allows, so each sentence is synthesized
+            whole.
+    """
+
+    model: SarvamModels
+    speaker: str
+    language: str
+    pace: float = 1.0
+    temperature: float = 0.6
+    dict_id: str | None = None
+    pitch: float | None = None
+    loudness: float | None = None
+    enable_preprocessing: bool | None = None
+    min_buffer_size: int | None = None
+    max_chunk_length: int | None = None
+
+    def __post_init__(self) -> None:
+        if self.model not in ("bulbul:v3", "bulbul:v4-flash"):
+            raise ValueError(
+                f"Sarvam model must be bulbul:v3 or bulbul:v4-flash, got {self.model!r}"
+            )
+        if not 0.5 <= self.pace <= 2.0:
+            raise ValueError(f"Sarvam pace must be between 0.5 and 2.0, got {self.pace}")
+        if not 0.01 <= self.temperature <= 1.0:
+            raise ValueError(
+                f"Sarvam temperature must be between 0.01 and 1.0, got {self.temperature}"
+            )
+        v4_only = {
+            "pitch": self.pitch,
+            "loudness": self.loudness,
+            "enable_preprocessing": self.enable_preprocessing,
+        }
+        given = [name for name, value in v4_only.items() if value is not None]
+        if given and self.model != "bulbul:v4-flash":
+            raise ValueError(f"Sarvam {', '.join(given)} need model bulbul:v4-flash")
+        if self.pitch is not None and not -0.5 <= self.pitch <= 0.5:
+            raise ValueError(f"Sarvam pitch must be between -0.5 and 0.5, got {self.pitch}")
+        if self.loudness is not None and not 0.1 <= self.loudness <= 2.5:
+            raise ValueError(f"Sarvam loudness must be between 0.1 and 2.5, got {self.loudness}")
+        if self.min_buffer_size is not None and not 30 <= self.min_buffer_size <= 200:
+            raise ValueError(
+                f"Sarvam min_buffer_size must be between 30 and 200, got {self.min_buffer_size}"
+            )
+        if self.max_chunk_length is not None and not 50 <= self.max_chunk_length <= 500:
+            raise ValueError(
+                f"Sarvam max_chunk_length must be between 50 and 500, got {self.max_chunk_length}"
+            )
+
+    @property
+    def provider_name(self) -> str:
+        return "Sarvam"
+
+    @property
+    def _sends_words(self) -> bool:
+        return False
+
+    def _start_fields(self) -> dict[str, Any]:
+        return {
+            "provider": "sarvam",
+            "model": self.model,
+            "voice": self.speaker,
+            "language": self.language,
+            "speed": self.pace,
+            "options": {
+                "temperature": self.temperature,
+                "dict_id": self.dict_id,
+                **{
+                    name: value
+                    for name, value in (
+                        ("pitch", self.pitch),
+                        ("loudness", self.loudness),
+                        ("enable_preprocessing", self.enable_preprocessing),
+                        ("min_buffer_size", self.min_buffer_size),
+                        ("max_chunk_length", self.max_chunk_length),
+                    )
+                    if value is not None
+                },
+            },
+        }
+
+
+@dataclass(frozen=True)
+class Raya:
+    """Raya Bakbak. The router calls Raya with the Raya API key stored for your org in the
+    dashboard.
+
+    Args:
+        model: ``"standard"`` or ``"m1"``.
+        voice_id: Raya voice id. Must belong to ``model``.
+        language: Raya language code, e.g. ``"hi"``.
+        speed: Speech speed, 0.5–1.5.
+    """
+
+    model: RayaModels
+    voice_id: str
+    language: str
+    speed: float = 1.0
+
+    def __post_init__(self) -> None:
+        if self.model not in ("m1", "standard"):
+            raise ValueError(f"Raya model must be m1 or standard, got {self.model!r}")
+        if not 0.5 <= self.speed <= 1.5:
+            raise ValueError(f"Raya speed must be between 0.5 and 1.5, got {self.speed}")
+
+    @property
+    def provider_name(self) -> str:
+        return "Raya"
+
+    @property
+    def _sends_words(self) -> bool:
+        return False
+
+    def _start_fields(self) -> dict[str, Any]:
+        return {
+            "provider": "raya",
+            "model": self.model,
+            "voice": self.voice_id,
+            "language": self.language,
+            "speed": self.speed,
+            "options": {},
+        }
+
+
+@dataclass(frozen=True)
+class VoiceSettings:
+    """ElevenLabs voice settings, as in ElevenLabs' LiveKit plugin.
+
+    Args:
+        stability: 0.0–1.0.
+        similarity_boost: 0.0–1.0.
+        style: 0.0–1.0.
+        speed: 0.7–1.2.
+        use_speaker_boost: Boost similarity to the original speaker.
+    """
+
+    stability: float
+    similarity_boost: float
+    style: float | None = None
+    speed: float | None = None
+    use_speaker_boost: bool | None = None
+
+    def __post_init__(self) -> None:
+        for name in ("stability", "similarity_boost", "style"):
+            value = getattr(self, name)
+            if value is not None and not 0.0 <= value <= 1.0:
+                raise ValueError(f"ElevenLabs {name} must be between 0.0 and 1.0, got {value}")
+        if self.speed is not None and not 0.7 <= self.speed <= 1.2:
+            raise ValueError(f"ElevenLabs speed must be between 0.7 and 1.2, got {self.speed}")
+
+    def _fields(self) -> dict[str, Any]:
+        fields: dict[str, Any] = {
+            "stability": self.stability,
+            "similarity_boost": self.similarity_boost,
+        }
+        for name in ("style", "speed", "use_speaker_boost"):
+            if getattr(self, name) is not None:
+                fields[name] = getattr(self, name)
+        return fields
+
+
+@dataclass(frozen=True)
+class PronunciationDictionaryLocator:
+    """An ElevenLabs pronunciation dictionary version."""
+
+    pronunciation_dictionary_id: str
+    version_id: str
+
+
+@dataclass(frozen=True)
+class ElevenLabs:
+    """ElevenLabs, with the settings of ElevenLabs' own LiveKit plugin. The router calls
+    ElevenLabs with the ElevenLabs API key stored for your org in the dashboard.
+
+    Args:
+        voice_id: ElevenLabs voice id.
+        model: ElevenLabs model, e.g. ``"eleven_flash_v2_5"``. ``eleven_v3`` and ``eleven_v4``
+            models go through ElevenLabs' text-to-dialogue API.
+        language: Optional language to enforce, e.g. ``"en"`` (``"en-US"`` and ``"english"``
+            are read as ``"en"``, as ElevenLabs' plugin reads them).
+        voice_settings: Optional voice settings; the voice's stored settings otherwise.
+        apply_text_normalization: ``"auto"``, ``"on"`` or ``"off"``.
+        apply_language_text_normalization: Language-specific normalization (Japanese).
+        enable_ssml_parsing: Parse SSML tags in the text.
+        enable_logging: ``False`` uses ElevenLabs' zero-retention mode (enterprise accounts).
+        pronunciation_dictionary_locators: Up to 3 pronunciation dictionaries.
+        sync_alignment: Word-level timed transcripts.
+        preferred_alignment: ``"normalized"`` or ``"original"`` text for the word timings;
+            ``"original"`` for Japanese, Korean and Chinese by default, else ``"normalized"``.
+    """
+
+    voice_id: str
+    model: ElevenLabsModels = "eleven_turbo_v2_5"
+    language: str | None = None
+    voice_settings: VoiceSettings | None = None
+    apply_text_normalization: Literal["auto", "on", "off"] = "auto"
+    apply_language_text_normalization: bool | None = None
+    enable_ssml_parsing: bool = False
+    enable_logging: bool = True
+    pronunciation_dictionary_locators: tuple[PronunciationDictionaryLocator, ...] = ()
+    sync_alignment: bool = True
+    preferred_alignment: Literal["normalized", "original"] | None = None
+
+    def __post_init__(self) -> None:
+        if self.model not in _ELEVENLABS_MODELS:
+            raise ValueError(
+                f"ElevenLabs model must be one of {', '.join(_ELEVENLABS_MODELS)}, "
+                f"got {self.model!r}"
+            )
+        if self.apply_text_normalization not in ("auto", "on", "off"):
+            raise ValueError(
+                "ElevenLabs apply_text_normalization must be auto, on or off, "
+                f"got {self.apply_text_normalization!r}"
+            )
+        if len(self.pronunciation_dictionary_locators) > 3:
+            raise ValueError("ElevenLabs takes at most 3 pronunciation dictionaries")
+        # A list is accepted too; keep the dataclass hashable.
+        object.__setattr__(
+            self,
+            "pronunciation_dictionary_locators",
+            tuple(self.pronunciation_dictionary_locators),
+        )
+
+    @property
+    def provider_name(self) -> str:
+        return "ElevenLabs"
+
+    @property
+    def _sends_words(self) -> bool:
+        return self.sync_alignment
+
+    def _start_fields(self) -> dict[str, Any]:
+        options: dict[str, Any] = {
+            "apply_text_normalization": self.apply_text_normalization,
+            "enable_ssml_parsing": self.enable_ssml_parsing,
+            "enable_logging": self.enable_logging,
+            "sync_alignment": self.sync_alignment,
+        }
+        if self.voice_settings is not None:
+            options["voice_settings"] = self.voice_settings._fields()
+        if self.apply_language_text_normalization is not None:
+            options["apply_language_text_normalization"] = self.apply_language_text_normalization
+        if self.pronunciation_dictionary_locators:
+            options["pronunciation_dictionary_locators"] = [
+                {
+                    "pronunciation_dictionary_id": d.pronunciation_dictionary_id,
+                    "version_id": d.version_id,
+                }
+                for d in self.pronunciation_dictionary_locators
+            ]
+        if self.preferred_alignment is not None:
+            options["preferred_alignment"] = self.preferred_alignment
+        fields: dict[str, Any] = {
+            "provider": "elevenlabs",
+            "model": self.model,
+            "voice": self.voice_id,
+            "options": options,
+        }
+        if self.language is not None:
+            # ElevenLabs takes ISO 639-1 codes; its LiveKit plugin sends the language this way.
+            fields["language"] = LanguageCode(self.language).language
+        return fields

livekit/plugins/tts_cache_router/tts.py

@@ -0,0 +1,517 @@
+# Copyright 2026 Oggnai Technologies Private Limited
+#
+# 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 dataclasses
+import json
+import os
+import time
+import weakref
+from collections.abc import AsyncIterable
+from typing import Any, cast
+
+import aiohttp
+from livekit.agents import (
+    APIConnectionError,
+    APIError,
+    APIStatusError,
+    APITimeoutError,
+    tts,
+    utils,
+)
+from livekit.agents.metrics import TTSMetrics
+from livekit.agents.metrics.base import Metadata
+from livekit.agents.types import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    NOT_GIVEN,
+    APIConnectOptions,
+    NotGivenOr,
+    TimedString,
+)
+from livekit.agents.utils import is_given
+
+from .log import logger
+from .providers import ElevenLabs, Raya, Sarvam
+
+DEFAULT_BASE_URL = "wss://api.ttscacherouter.dev"
+API_KEY_ENV = "TTS_CACHE_ROUTER_API_KEY"
+SUPPORTED_SAMPLE_RATES = (8000, 16000, 22050, 24000)
+# ElevenLabs also streams these.
+ELEVENLABS_SAMPLE_RATES = (8000, 16000, 22050, 24000, 32000, 44100, 48000)
+
+# The router closes connections idle for longer than its idle timeout (300 s on the hosted
+# router); pooled sockets are retired well before that.
+_MAX_SESSION_DURATION = 240
+
+# After a barge-in, how long to wait for the router to confirm the cancel before giving up on
+# reusing the connection.
+_CANCEL_TIMEOUT_S = 2.0
+
+# Router error code → HTTP-like status, when the provider gave none.
+_STATUS_FOR_CODE = {
+    "bad_request": 400,
+    "unauthorized": 401,
+    "insufficient_credits": 402,
+    "provider_key_missing": 400,
+    "provider_rejected": 400,
+    "provider_rate_limited": 429,
+    "provider_unavailable": 502,
+    "provider_timeout": 504,
+    "internal": 500,
+}
+
+
+class TTS(tts.TTS[Any]):
+    def __init__(
+        self,
+        *,
+        provider: Sarvam | Raya | ElevenLabs,
+        api_key: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        sample_rate: int = 24000,
+        http_session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        """Text-to-speech through tts-cache-router.
+
+        Sentences your org has synthesized before with the same voice and settings are replayed
+        from its cache; the rest are synthesized by the provider with the provider key stored for
+        your org in the dashboard. The audio is the provider's own: a cache hit replays a real
+        take for that exact request.
+
+        Args:
+            provider: ``Sarvam(...)``, ``Raya(...)`` or ``ElevenLabs(...)``: the provider, voice
+                and settings to use.
+            api_key: Router API key. Defaults to the ``TTS_CACHE_ROUTER_API_KEY`` environment
+                variable.
+            base_url: Router URL. Defaults to the hosted router.
+            sample_rate: 8000, 16000, 22050 or 24000; ElevenLabs also 32000, 44100 or 48000.
+            http_session: Optional aiohttp session; defaults to the job's.
+        """
+        super().__init__(
+            capabilities=tts.TTSCapabilities(streaming=True, aligned_transcript=True),
+            sample_rate=sample_rate,
+            num_channels=1,
+        )
+        router_key = api_key or os.environ.get(API_KEY_ENV)
+        if not router_key:
+            raise ValueError(
+                f"tts-cache-router API key is required, either as api_key or set {API_KEY_ENV}"
+            )
+        _check_sample_rate(provider, sample_rate)
+
+        self._provider = provider
+        self._api_key = router_key
+        self._url = f"{base_url.rstrip('/')}/v1/stream"
+        self._session = http_session
+        self._pool = utils.ConnectionPool[aiohttp.ClientWebSocketResponse](
+            connect_cb=self._connect_ws,
+            close_cb=self._close_ws,
+            max_session_duration=_MAX_SESSION_DURATION,
+            mark_refreshed_on_get=True,
+        )
+        self._streams = weakref.WeakSet[SynthesizeStream]()
+        self._background: set[asyncio.Task[Any]] = set()
+
+    def update_options(
+        self,
+        *,
+        provider: NotGivenOr[Sarvam | Raya | ElevenLabs] = NOT_GIVEN,
+        **settings: Any,
+    ) -> None:
+        """Change the provider or its settings. Segments that start from now on use them.
+
+        Args:
+            provider: A new ``Sarvam(...)``, ``Raya(...)`` or ``ElevenLabs(...)``.
+            **settings: Settings of the provider to change, in its own names, e.g.
+                ``update_options(speaker="priya", pace=1.1)`` for Sarvam or
+                ``update_options(voice_id="…")`` for ElevenLabs.
+        """
+        new = provider if is_given(provider) else self._provider
+        if settings:
+            # Validated by the provider's own constructor.
+            new = dataclasses.replace(new, **settings)
+        _check_sample_rate(new, self.sample_rate)
+        self._provider = new
+
+    @property
+    def model(self) -> str:
+        return self._provider.model
+
+    @property
+    def provider(self) -> str:
+        # The underlying provider, so usage dashboards attribute cost to whoever charges for it.
+        return self._provider.provider_name
+
+    def _ensure_session(self) -> aiohttp.ClientSession:
+        if not self._session:
+            self._session = utils.http_context.http_session()
+        return self._session
+
+    async def _connect_ws(self, timeout: float) -> aiohttp.ClientWebSocketResponse:
+        async def connect() -> aiohttp.ClientWebSocketResponse:
+            ws = await self._ensure_session().ws_connect(
+                self._url, headers={"Authorization": f"Bearer {self._api_key}"}
+            )
+            # aiohttp types text frames per `decode_text`; this module reads them as str.
+            return cast(aiohttp.ClientWebSocketResponse, ws)
+
+        try:
+            return await asyncio.wait_for(connect(), timeout)
+        except asyncio.TimeoutError:
+            raise APITimeoutError("timed out connecting to tts-cache-router") from None
+        except aiohttp.WSServerHandshakeError as e:
+            if e.status == 403:
+                raise APIStatusError(
+                    "tts-cache-router refused the account key",
+                    status_code=403,
+                    retryable=False,
+                ) from None
+            if e.status == 402:
+                raise APIStatusError(
+                    "tts-cache-router: this org is out of credit, so new connections are refused;"
+                    " buy credit in the dashboard (Billing)",
+                    status_code=402,
+                    retryable=False,
+                ) from None
+            raise APIStatusError(
+                f"tts-cache-router refused the connection: {e.message}",
+                status_code=e.status,
+            ) from None
+        except Exception as e:
+            raise APIConnectionError(
+                f"connecting to tts-cache-router failed: {type(e).__name__}"
+            ) from None
+
+    async def _close_ws(self, ws: aiohttp.ClientWebSocketResponse) -> None:
+        await ws.close()
+
+    def _in_background(self, coro: Any) -> None:
+        task = asyncio.create_task(coro)
+        self._background.add(task)
+        task.add_done_callback(self._background.discard)
+
+    def _discard(self, ws: aiohttp.ClientWebSocketResponse) -> None:
+        # Closing promptly tells the router the client is gone, so it stops sending audio nobody
+        # will play. The pool would otherwise close it only on its next use.
+        self._pool.remove(ws)
+        self._in_background(ws.close())
+
+    async def _cancel_segment(self, ws: aiohttp.ClientWebSocketResponse, segment_id: str) -> None:
+        """Barge-in: stop the segment but keep the connection warm for the next turn. Audio
+        still in flight for the segment is discarded until the router confirms the cancel."""
+
+        async def confirmed() -> None:
+            await ws.send_str(json.dumps({"type": "cancel", "segment_id": segment_id}))
+            while True:
+                msg = await ws.receive()
+                if msg.type == aiohttp.WSMsgType.BINARY:
+                    continue
+                if msg.type != aiohttp.WSMsgType.TEXT:
+                    raise ConnectionError("tts-cache-router closed the connection")
+                data = json.loads(msg.data)
+                if data["type"] == "cancelled" and data["segment_id"] == segment_id:
+                    return
+                if data["type"] == "error":
+                    raise ConnectionError(f"tts-cache-router error {data['code']}")
+
+        try:
+            await asyncio.wait_for(confirmed(), _CANCEL_TIMEOUT_S)
+        except Exception as e:
+            logger.debug(
+                "could not reuse the connection after a cancel",
+                extra={"error": type(e).__name__},
+            )
+            self._discard(ws)
+            return
+        self._pool.put(ws)
+
+    def prewarm(self) -> None:
+        self._pool.prewarm()
+
+    def synthesize(
+        self,
+        text: str,
+        *,
+        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
+    ) -> ChunkedStream:
+        return ChunkedStream(tts=self, input_text=text, conn_options=conn_options)
+
+    def stream(
+        self, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
+    ) -> SynthesizeStream:
+        stream = SynthesizeStream(tts=self, conn_options=conn_options)
+        self._streams.add(stream)
+        return stream
+
+    async def aclose(self) -> None:
+        for stream in list(self._streams):
+            await stream.aclose()
+        self._streams.clear()
+        await utils.aio.gracefully_cancel(*self._background)
+        await self._pool.aclose()
+
+    def _start_message(
+        self, segment_id: str, provider: Sarvam | Raya | ElevenLabs
+    ) -> dict[str, Any]:
+        return {
+            "type": "start",
+            "segment_id": segment_id,
+            "sample_rate": self.sample_rate,
+            "format": "pcm",
+            **provider._start_fields(),
+        }
+
+
+def _check_sample_rate(provider: Sarvam | Raya | ElevenLabs, sample_rate: int) -> None:
+    rates = ELEVENLABS_SAMPLE_RATES if isinstance(provider, ElevenLabs) else SUPPORTED_SAMPLE_RATES
+    if sample_rate not in rates:
+        raise ValueError(
+            f"sample_rate must be one of {rates} for {provider.provider_name}, got {sample_rate}"
+        )
+
+
+def _router_error(data: dict[str, Any]) -> APIError:
+    status = data.get("provider_status") or _STATUS_FOR_CODE.get(data["code"], 500)
+    return APIStatusError(
+        f"tts-cache-router {data['code']}: {data['message']}",
+        status_code=status,
+        body=data,
+        retryable=bool(data["retryable"]),
+    )
+
+
+def _initialize(output_emitter: tts.AudioEmitter, sample_rate: int, *, streamed: bool) -> str:
+    """Returns the request id."""
+    request_id = utils.shortuuid()
+    output_emitter.initialize(
+        request_id=request_id,
+        sample_rate=sample_rate,
+        num_channels=1,
+        mime_type="audio/pcm",
+        stream=streamed,
+    )
+    return request_id
+
+
+async def _run_segment(
+    stream: SynthesizeStream | ChunkedStream,
+    output_emitter: tts.AudioEmitter,
+    *,
+    request_id: str,
+    send_input: Any,
+    streamed: bool,
+) -> None:
+    """One router segment: `start`, text, `flush`, then audio until `done`.
+
+    `send_input(ws, segment_id, first_text_at)` sends the `text` messages and the `flush`.
+    """
+    router_tts: TTS = stream._tts
+    conn_options = stream._conn_options
+    sample_rate = router_tts.sample_rate
+    segment_id = utils.shortuuid()
+    # The settings as of the segment's start: update_options applies from the next segment.
+    provider = router_tts._provider
+    if streamed:
+        output_emitter.start_segment(segment_id=segment_id)
+
+    started = time.perf_counter()
+    first_text_at: list[float] = []
+    first_audio_at: float | None = None
+    pushed_bytes = 0
+    done: dict[str, Any] | None = None
+    # With word timings (ElevenLabs), transcripts follow the words; else each sentence.
+    words = provider._sends_words
+    sentence_start = 0.0
+
+    async def sender(ws: aiohttp.ClientWebSocketResponse) -> None:
+        await ws.send_str(json.dumps(router_tts._start_message(segment_id, provider)))
+        await send_input(ws, segment_id, first_text_at)
+
+    pool = router_tts._pool
+    try:
+        ws = await pool.get(timeout=conn_options.timeout)
+    except APIError:
+        raise
+    except Exception as e:
+        raise APIConnectionError(
+            f"connecting to tts-cache-router failed: {type(e).__name__}"
+        ) from e
+    stream._acquire_time = pool.last_acquire_time
+    stream._connection_reused = pool.last_connection_reused
+    send_task = asyncio.create_task(sender(ws))
+    try:
+        while done is None:
+            try:
+                msg = await ws.receive(timeout=conn_options.timeout)
+            except asyncio.TimeoutError:
+                # Until all input is sent, silence just means the LLM is still talking.
+                if send_task.done():
+                    send_task.result()
+                    raise APITimeoutError("tts-cache-router sent nothing in time") from None
+                continue
+
+            if msg.type == aiohttp.WSMsgType.BINARY:
+                if first_audio_at is None:
+                    first_audio_at = time.perf_counter()
+                pushed_bytes += len(msg.data)
+                output_emitter.push(msg.data)
+                continue
+            if msg.type != aiohttp.WSMsgType.TEXT:
+                raise APIConnectionError("tts-cache-router closed the connection")
+
+            data = json.loads(msg.data)
+            if data["type"] == "sentence":
+                sentence_start = pushed_bytes / 2 / sample_rate
+                if not words:
+                    # Transcripts stay in step with speech at sentence granularity.
+                    output_emitter.push_timed_transcript(
+                        TimedString(text=data["text"] + " ", start_time=sentence_start)
+                    )
+            elif data["type"] == "words":
+                # Word by word, as ElevenLabs' own plugin aligns them.
+                output_emitter.push_timed_transcript(
+                    [
+                        TimedString(
+                            text=w["text"],
+                            start_time=sentence_start + w["start"],
+                            end_time=sentence_start + w["end"],
+                        )
+                        for w in data["words"]
+                    ]
+                )
+            elif data["type"] == "done":
+                done = data
+            elif data["type"] == "error":
+                raise _router_error(data)
+            else:
+                logger.warning("unexpected tts-cache-router message", extra={"type": data["type"]})
+        send_task.result()
+    except asyncio.CancelledError:
+        # Barge-in. The `start` may already be out, so ask the router to cancel the segment (a
+        # no-op it still confirms if the segment never started or already finished), and return
+        # the warm connection to the pool once it confirms.
+        await utils.aio.gracefully_cancel(send_task)
+        router_tts._in_background(router_tts._cancel_segment(ws, segment_id))
+        raise
+    except APIError:
+        router_tts._discard(ws)
+        raise
+    except Exception as e:
+        router_tts._discard(ws)
+        raise APIConnectionError(f"tts-cache-router connection failed: {type(e).__name__}") from e
+    finally:
+        await utils.aio.gracefully_cancel(send_task)
+    pool.put(ws)
+
+    if streamed:
+        output_emitter.end_segment()
+    else:
+        output_emitter.flush()
+
+    # Cache hits are not provider characters: report only what the provider billed.
+    ttfb = first_audio_at - first_text_at[0] if first_audio_at and first_text_at else -1.0
+    router_tts.emit(
+        "metrics_collected",
+        TTSMetrics(
+            timestamp=time.time(),
+            request_id=request_id,
+            segment_id=segment_id if streamed else None,
+            ttfb=ttfb,
+            duration=time.perf_counter() - started,
+            characters_count=done["billed_characters"],
+            audio_duration=pushed_bytes / 2 / sample_rate,
+            cancelled=False,
+            label=router_tts.label,
+            streamed=streamed,
+            acquire_time=stream._acquire_time,
+            connection_reused=stream._connection_reused,
+            metadata=Metadata(model_name=provider.model, model_provider=provider.provider_name),
+        ),
+    )
+
+
+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
+
+    # Overrides a private method (verified on livekit-agents 1.8.5): the base class reports
+    # len(input_text) as provider characters, which would bill cache hits. _run_segment emits
+    # the metrics with the router's billed_characters instead.
+    async def _metrics_monitor_task(self, event_aiter: AsyncIterable[tts.SynthesizedAudio]) -> None:
+        async for _ in event_aiter:
+            pass
+
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        async def send_input(
+            ws: aiohttp.ClientWebSocketResponse,
+            segment_id: str,
+            first_text_at: list[float],
+        ) -> None:
+            if self._input_text:
+                first_text_at.append(time.perf_counter())
+                await ws.send_str(
+                    json.dumps(
+                        {
+                            "type": "text",
+                            "segment_id": segment_id,
+                            "text": self._input_text,
+                        }
+                    )
+                )
+            await ws.send_str(json.dumps({"type": "flush", "segment_id": segment_id}))
+
+        request_id = _initialize(output_emitter, self._tts.sample_rate, streamed=False)
+        await _run_segment(
+            self, output_emitter, request_id=request_id, send_input=send_input, streamed=False
+        )
+
+
+class SynthesizeStream(tts.SynthesizeStream):
+    def __init__(self, *, tts: TTS, conn_options: APIConnectOptions) -> None:
+        super().__init__(tts=tts, conn_options=conn_options)
+        self._tts: TTS = tts
+
+    # Overrides a private method (verified on livekit-agents 1.8.5): the base class reports
+    # len(text) as provider characters, which would bill cache hits. _run_segment emits the
+    # metrics with the router's billed_characters instead.
+    async def _metrics_monitor_task(self, event_aiter: AsyncIterable[tts.SynthesizedAudio]) -> None:
+        async for _ in event_aiter:
+            pass
+
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        async def send_input(
+            ws: aiohttp.ClientWebSocketResponse,
+            segment_id: str,
+            first_text_at: list[float],
+        ) -> None:
+            # One stream is one router segment: livekit-agents passes on no text after the first
+            # flush (one SynthesizeStream per segment).
+            async for data in self._input_ch:
+                if isinstance(data, self._FlushSentinel):
+                    break
+                if not first_text_at:
+                    first_text_at.append(time.perf_counter())
+                self._mark_started()
+                await ws.send_str(
+                    json.dumps({"type": "text", "segment_id": segment_id, "text": data})
+                )
+            await ws.send_str(json.dumps({"type": "flush", "segment_id": segment_id}))
+
+        request_id = _initialize(output_emitter, self._tts.sample_rate, streamed=True)
+        await _run_segment(
+            self, output_emitter, request_id=request_id, send_input=send_input, streamed=True
+        )

livekit/plugins/tts_cache_router/version.py

@@ -0,0 +1,15 @@
+# Copyright 2026 Oggnai Technologies Private Limited
+#
+# 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.
+
+__version__ = "0.1.0"

livekit_plugins_tts_cache_router-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.5
+Name: livekit-plugins-tts-cache-router
+Version: 0.1.0
+Summary: LiveKit Agents plugin for tts-cache-router, a caching TTS router for Sarvam, Raya and ElevenLabs
+Project-URL: Homepage, https://ttscacherouter.dev
+Project-URL: Documentation, https://docs.ttscacherouter.dev/livekit
+Project-URL: Source, https://github.com/talqing/tts-cache-router
+Author: Oggnai Technologies Private Limited
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: ai,audio,cache,elevenlabs,livekit,raya,realtime,sarvam,tts,voice
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10.0
+Requires-Dist: livekit-agents>=1.8.5
+Description-Content-Type: text/markdown
+
+# livekit-plugins-tts-cache-router
+
+[LiveKit Agents](https://github.com/livekit/agents) plugin for
+[tts-cache-router](https://ttscacherouter.dev): Sarvam, Raya and ElevenLabs text-to-speech,
+with every sentence your agent has said before served from a per-account cache.
+
+Same output whether you call the provider directly or through the router: each sentence reaches
+the provider verbatim with your exact settings, and a cache hit replays a real provider take for
+that exact request.
+
+Full documentation: [docs.ttscacherouter.dev/livekit](https://docs.ttscacherouter.dev/livekit).
+
+## Install
+
+```bash
+pip install livekit-plugins-tts-cache-router
+```
+
+## Usage
+
+```python
+from livekit.plugins import tts_cache_router
+
+tts = tts_cache_router.TTS(
+    provider=tts_cache_router.Sarvam(model="bulbul:v3", speaker="shubh", language="hi-IN"),
+)
+# or
+tts = tts_cache_router.TTS(
+    provider=tts_cache_router.Raya(
+        model="standard", voice_id="d6a002d0-230c-49b1-a137-b8a7d564b1ae", language="hi"
+    ),
+)
+# or
+tts = tts_cache_router.TTS(
+    provider=tts_cache_router.ElevenLabs(voice_id="JBFqnCBsd6RMkjVDRZzb", model="eleven_flash_v2_5"),
+)
+
+session = AgentSession(tts=tts, ...)
+```
+
+Before the first request, store your Sarvam, Raya or ElevenLabs API key in the dashboard at
+[ttscacherouter.dev](https://ttscacherouter.dev/dashboard/provider-keys). The router keeps it
+encrypted and uses it only to call that provider for your requests.
+
+Set `TTS_CACHE_ROUTER_API_KEY` to your router API key, from the same dashboard (or pass
+`api_key=`).
+
+### `TTS(...)`
+
+| Argument | Default | |
+|---|---|---|
+| `provider` | required | `Sarvam(...)`, `Raya(...)` or `ElevenLabs(...)` |
+| `api_key` | `$TTS_CACHE_ROUTER_API_KEY` | router API key |
+| `base_url` | `wss://api.ttscacherouter.dev` | set to your own router when self-hosting |
+| `sample_rate` | `24000` | 8000, 16000, 22050 or 24000; ElevenLabs also 32000, 44100 or 48000 |
+
+How long cached audio is kept is your org's retention setting, in the dashboard.
+
+### `Sarvam(...)`
+
+`model` (`"bulbul:v3"` or `"bulbul:v4-flash"`), `speaker`, `language` (e.g. `"hi-IN"`),
+`pace` (0.5–2.0, default 1.0), `temperature` (0.01–1.0, default 0.6), `dict_id`, and for
+`bulbul:v4-flash` only: `pitch` (-0.5–0.5), `loudness` (0.1–2.5), `enable_preprocessing`;
+`min_buffer_size` (30–200) and `max_chunk_length` (50–500; by default each sentence is
+synthesized whole).
+
+### `Raya(...)`
+
+`model` (`"standard"` or `"m1"`), `voice_id`, `language` (e.g. `"hi"`), `speed` (0.5–1.5,
+default 1.0).
+
+### `ElevenLabs(...)`
+
+The settings of ElevenLabs' own LiveKit plugin: `voice_id`, `model` (default
+`"eleven_turbo_v2_5"`; `eleven_v3` and `eleven_v4` models go through ElevenLabs' text-to-dialogue
+API), `language` (optional; `"en-US"` or `"english"` is sent as `"en"`, as ElevenLabs' plugin
+sends it), `voice_settings` (`VoiceSettings(stability, similarity_boost,
+style=None, speed=None, use_speaker_boost=None)`; the voice's stored settings when omitted),
+`apply_text_normalization` (`"auto"`, `"on"` or `"off"`), `apply_language_text_normalization`,
+`enable_ssml_parsing`, `enable_logging`, `pronunciation_dictionary_locators`
+(`PronunciationDictionaryLocator(pronunciation_dictionary_id, version_id)`, up to 3),
+`sync_alignment` (default `True`: word-level timed transcripts) and `preferred_alignment`
+(`"normalized"` or `"original"`).
+
+### Changing settings mid-session
+
+```python
+tts.update_options(speaker="priya", pace=1.1)  # the current provider's settings, by name
+tts.update_options(provider=tts_cache_router.Raya(...))  # or another provider
+```
+
+Replies that start afterwards use the new settings.
+
+### Interruptions
+
+When the agent is interrupted, the plugin cancels the router segment and keeps the connection open,
+so the next reply starts on a warm connection.
+
+### Metrics
+
+`TTSMetrics.characters_count` counts only characters the provider synthesized (and billed) for
+the request; sentences served from the cache count zero. `provider` and `model` report the
+underlying provider, so usage dashboards attribute cost correctly.

livekit_plugins_tts_cache_router-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+livekit/plugins/tts_cache_router/__init__.py,sha256=OXR7NELx9SxMuSISsys-N9IEeZghFx_zY1pF2m2q18U,1649
+livekit/plugins/tts_cache_router/log.py,sha256=nEtTyiwCvYSGS3ZKwz7N_ASSuEAUqkiHmfBuVbJ0b-s,79
+livekit/plugins/tts_cache_router/providers.py,sha256=2Ewqyf3tZe4xwMFnZm5wtQLBMhPhz5zIIO_D15AW_ZE,12523
+livekit/plugins/tts_cache_router/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+livekit/plugins/tts_cache_router/tts.py,sha256=nqJHNYqWBZfh7_VPdVVZtdS21eb28Y4WlsXiOBCDuBk,20257
+livekit/plugins/tts_cache_router/version.py,sha256=XM9ITzC_IaEPTFvYwLyNKIqN9OhcXUa2ZONCeDVWYLo,622
+livekit_plugins_tts_cache_router-0.1.0.dist-info/METADATA,sha256=1EIsDPHJ-_CAiX6O0NFe3zgX_txmKibWwwY6U4tsG80,5105
+livekit_plugins_tts_cache_router-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+livekit_plugins_tts_cache_router-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+livekit_plugins_tts_cache_router-0.1.0.dist-info/RECORD,,

livekit_plugins_tts_cache_router-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

livekit_plugins_tts_cache_router-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.