livekit-plugins-sarvam 1.1.0__tar.gz

livekit_plugins_sarvam-1.1.0/.gitignore

@@ -0,0 +1,172 @@
+**/.vscode
+**/.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# trunk
+.trunk/
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+node_modules
+
+credentials.json
+pyrightconfig.json
+docs/

livekit_plugins_sarvam-1.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: livekit-plugins-sarvam
+Version: 1.1.0
+Summary: Agent Framework plugin for services using Sarvam.ai's API.
+Project-URL: Documentation, https://docs.livekit.io
+Project-URL: Website, https://livekit.io/
+Project-URL: Source, https://github.com/livekit/agents
+Author-email: LiveKit <hello@livekit.io>
+License-Expression: Apache-2.0
+Keywords: audio,indian-languages,indic,livekit,realtime,sarvam,stt,tts,video,webrtc
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9.0
+Requires-Dist: livekit-agents[codecs]>=1.1.0
+Requires-Dist: numpy>=1.26
+Description-Content-Type: text/markdown
+
+# Sarvam.ai Plugin for LiveKit Agents
+
+This plugin provides integration with [Sarvam.ai](https://sarvam.ai) services for LiveKit Agents.
+
+## Features
+
+- **Speech-to-Text (STT)**: Convert audio to text using Sarvam's "Saarika" models
+- **Text-to-Speech (TTS)**: Convert text to audio using Sarvam's "Bulbul" models
+
+Sarvam.ai specializes in high-quality STT and TTS for Indian languages, supporting multiple dialects and accents.
+
+## Requirements
+
+- Sarvam.ai API key
+- Python 3.9 or higher
+
+## Installation
+
+```bash
+pip install livekit-plugins-sarvam
+``` 

livekit_plugins_sarvam-1.1.0/README.md

@@ -0,0 +1,21 @@
+# Sarvam.ai Plugin for LiveKit Agents
+
+This plugin provides integration with [Sarvam.ai](https://sarvam.ai) services for LiveKit Agents.
+
+## Features
+
+- **Speech-to-Text (STT)**: Convert audio to text using Sarvam's "Saarika" models
+- **Text-to-Speech (TTS)**: Convert text to audio using Sarvam's "Bulbul" models
+
+Sarvam.ai specializes in high-quality STT and TTS for Indian languages, supporting multiple dialects and accents.
+
+## Requirements
+
+- Sarvam.ai API key
+- Python 3.9 or higher
+
+## Installation
+
+```bash
+pip install livekit-plugins-sarvam
+``` 

livekit_plugins_sarvam-1.1.0/livekit/plugins/sarvam/__init__.py

@@ -0,0 +1,50 @@
+# Copyright 2025 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.
+
+"""Sarvam.ai plugin for LiveKit Agents
+
+Support for speech-to-text and text-to-speech with [Sarvam.ai](https://sarvam.ai/).
+
+Sarvam.ai provides high-quality STT and TTS for Indian languages.
+
+For API access, visit https://sarvam.ai/
+"""
+
+from .stt import STT
+from .tts import TTS
+from .version import __version__
+
+__all__ = ["STT", "TTS", "__version__"]
+
+
+from livekit.agents import Plugin
+
+from .log import logger
+
+
+class SarvamPlugin(Plugin):
+    def __init__(self) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+
+
+Plugin.register_plugin(SarvamPlugin())
+
+# 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_sarvam-1.1.0/livekit/plugins/sarvam/log.py

@@ -0,0 +1,4 @@
+# Simple logger for the plugin
+import logging
+
+logger = logging.getLogger(__name__)

livekit_plugins_sarvam-1.1.0/livekit/plugins/sarvam/py.typed

@@ -0,0 +1 @@
+ 

livekit_plugins_sarvam-1.1.0/livekit/plugins/sarvam/stt.py

@@ -0,0 +1,244 @@
+# Copyright 2025 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.
+
+"""Speech-to-Text implementation for Sarvam.ai
+
+This module provides an STT implementation that uses the Sarvam.ai API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from dataclasses import dataclass
+from typing import Literal
+
+import aiohttp
+
+from livekit import rtc
+from livekit.agents import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    APIConnectionError,
+    APIConnectOptions,
+    APIStatusError,
+    APITimeoutError,
+    stt,
+    utils,
+)
+from livekit.agents.types import NOT_GIVEN, NotGivenOr
+from livekit.agents.utils import AudioBuffer
+
+from .log import logger
+
+# Sarvam API details
+SARVAM_STT_BASE_URL = "https://api.sarvam.ai/speech-to-text"
+
+# Supported Sarvam models
+SarvamSTTModels = Literal["saarika:v1", "saarika:v2", "saarika:flash"]
+
+
+@dataclass
+class SarvamSTTOptions:
+    """Options for the Sarvam.ai STT service.
+
+    Args:
+        language: BCP-47 language code, e.g., "hi-IN", "en-IN"
+        model: The Sarvam STT model to use
+        api_key: Sarvam.ai API key
+        base_url: API endpoint URL
+    """
+
+    language: str  # BCP-47 language code, e.g., "hi-IN", "en-IN"
+    model: SarvamSTTModels | str = "saarika:v2"
+    api_key: str | None = None
+    base_url: str = SARVAM_STT_BASE_URL
+
+
+class STT(stt.STT):
+    """Sarvam.ai Speech-to-Text implementation.
+
+    This class provides speech-to-text functionality using the Sarvam.ai API.
+    Sarvam.ai specializes in high-quality STT for Indian languages.
+
+    Args:
+        language: BCP-47 language code, e.g., "hi-IN", "en-IN"
+        model: The Sarvam STT model to use
+        api_key: Sarvam.ai API key (falls back to SARVAM_API_KEY env var)
+        base_url: API endpoint URL
+        http_session: Optional aiohttp session to use
+    """
+
+    def __init__(
+        self,
+        *,
+        language: str,
+        model: SarvamSTTModels | str = "saarika:v2",
+        api_key: str | None = None,
+        base_url: str = SARVAM_STT_BASE_URL,
+        http_session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        super().__init__(capabilities=stt.STTCapabilities(streaming=False, interim_results=False))
+
+        self._api_key = api_key or os.environ.get("SARVAM_API_KEY")
+        if not self._api_key:
+            raise ValueError(
+                "Sarvam API key is required. "
+                "Provide it directly or set SARVAM_API_KEY environment variable."
+            )
+
+        self._opts = SarvamSTTOptions(
+            language=language,
+            model=model,
+            api_key=self._api_key,
+            base_url=base_url,
+        )
+        self._session = http_session
+        self._logger = logger.getChild(self.__class__.__name__)
+
+    def _ensure_session(self) -> aiohttp.ClientSession:
+        if not self._session:
+            self._session = utils.http_context.http_session()
+        return self._session
+
+    async def _recognize_impl(
+        self,
+        buffer: AudioBuffer,
+        *,
+        language: NotGivenOr[str] = NOT_GIVEN,
+        model: NotGivenOr[SarvamSTTModels | str] = NOT_GIVEN,
+        conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS,
+    ) -> stt.SpeechEvent:
+        """Recognize speech using Sarvam.ai API.
+
+        Args:
+            buffer: Audio buffer containing speech data
+            language: BCP-47 language code (overrides the one set in constructor)
+            model: Sarvam model to use (overrides the one set in constructor)
+            conn_options: Connection options for API requests
+
+        Returns:
+            A SpeechEvent containing the transcription result
+
+        Raises:
+            APIConnectionError: On network connection errors
+            APIStatusError: On API errors (non-200 status)
+            APITimeoutError: On API timeout
+        """
+        opts_language = self._opts.language if isinstance(language, type(NOT_GIVEN)) else language
+        opts_model = self._opts.model if isinstance(model, type(NOT_GIVEN)) else model
+
+        wav_bytes = rtc.combine_audio_frames(buffer).to_wav_bytes()
+
+        form_data = aiohttp.FormData()
+        form_data.add_field("file", wav_bytes, filename="audio.wav", content_type="audio/wav")
+
+        # Add model and language_code to the form data if specified
+        # Sarvam API docs state language_code is optional for saarika:v2 but mandatory for v1
+        # Model is also optional, defaults to saarika:v2
+        if opts_language:
+            form_data.add_field("language_code", opts_language)
+        if opts_model:
+            form_data.add_field("model", str(opts_model))
+
+        headers = {"api-subscription-key": self._opts.api_key}
+
+        try:
+            async with self._ensure_session().post(
+                url=self._opts.base_url,
+                data=form_data,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(
+                    total=conn_options.timeout,
+                    sock_connect=conn_options.timeout,
+                ),
+            ) as res:
+                if res.status != 200:
+                    error_text = await res.text()
+                    self._logger.error(f"Sarvam API error: {res.status} - {error_text}")
+                    raise APIStatusError(
+                        message=f"Sarvam API Error: {error_text}",
+                        status_code=res.status,
+                    )
+
+                response_json = await res.json()
+                self._logger.debug(f"Sarvam API response: {response_json}")
+
+                transcript_text = response_json.get("transcript", "")
+                request_id = response_json.get("request_id", "")
+                detected_language = response_json.get("language_code")
+                if not isinstance(detected_language, str):
+                    detected_language = opts_language or ""
+
+                start_time = 0.0
+                end_time = 0.0
+
+                # Try to get timestamps if available
+                timestamps_data = response_json.get("timestamps")
+                if timestamps_data and isinstance(timestamps_data, dict):
+                    words_ts_start = timestamps_data.get("start_time_seconds")
+                    words_ts_end = timestamps_data.get("end_time_seconds")
+                    if isinstance(words_ts_start, list) and len(words_ts_start) > 0:
+                        start_time = words_ts_start[0]
+                    if isinstance(words_ts_end, list) and len(words_ts_end) > 0:
+                        end_time = words_ts_end[-1]
+
+                # If start/end times are still 0, use buffer duration as an estimate for end_time
+                if start_time == 0.0 and end_time == 0.0:
+                    # Calculate duration from buffer - AudioBuffer can be list[AudioFrame]
+                    # or AudioFrame
+                    try:
+                        if isinstance(buffer, list):
+                            # Calculate total duration from all frames
+                            total_samples = sum(frame.samples_per_channel for frame in buffer)
+                            if buffer and total_samples > 0:
+                                sample_rate = buffer[0].sample_rate
+                                end_time = total_samples / sample_rate
+                        elif hasattr(buffer, "duration"):
+                            end_time = buffer.duration / 1000.0  # buffer.duration is in ms
+                        elif hasattr(buffer, "samples_per_channel") and hasattr(
+                            buffer, "sample_rate"
+                        ):
+                            # Single AudioFrame
+                            end_time = buffer.samples_per_channel / buffer.sample_rate
+                    except Exception as duration_error:
+                        self._logger.warning(
+                            f"Could not calculate audio duration: {duration_error}"
+                        )
+                        end_time = 0.0
+
+                alternatives = [
+                    stt.SpeechData(
+                        language=detected_language,
+                        text=transcript_text,
+                        start_time=start_time,
+                        end_time=end_time,
+                        confidence=1.0,  # Sarvam doesn't provide confidence score in this response
+                    )
+                ]
+
+                return stt.SpeechEvent(
+                    type=stt.SpeechEventType.FINAL_TRANSCRIPT,
+                    request_id=request_id,
+                    alternatives=alternatives,
+                )
+
+        except asyncio.TimeoutError as e:
+            self._logger.error(f"Sarvam API timeout: {e}")
+            raise APITimeoutError("Sarvam API request timed out") from e
+        except aiohttp.ClientError as e:
+            self._logger.error(f"Sarvam API client error: {e}")
+            raise APIConnectionError(f"Sarvam API connection error: {e}") from e
+        except Exception as e:
+            self._logger.error(f"Error during Sarvam STT processing: {e}")
+            raise APIConnectionError(f"Unexpected error in Sarvam STT: {e}") from e

livekit_plugins_sarvam-1.1.0/livekit/plugins/sarvam/tts.py

@@ -0,0 +1,274 @@
+# Copyright 2025 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.
+
+"""Text-to-Speech implementation for Sarvam.ai
+
+This module provides a TTS implementation that uses the Sarvam.ai API.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import os
+from dataclasses import dataclass, replace
+from typing import Literal
+
+import aiohttp
+
+from livekit.agents import (
+    DEFAULT_API_CONNECT_OPTIONS,
+    APIConnectionError,
+    APIConnectOptions,
+    APIStatusError,
+    APITimeoutError,
+    tts,
+    utils,
+)
+
+from .log import logger
+
+SARVAM_TTS_BASE_URL = "https://api.sarvam.ai/text-to-speech"
+
+# Sarvam TTS specific models and speakers
+SarvamTTSModels = Literal["bulbul:v2"]
+
+# Supported languages in BCP-47 format
+SarvamTTSLanguages = Literal[
+    "bn-IN",  # Bengali
+    "en-IN",  # English (India)
+    "gu-IN",  # Gujarati
+    "hi-IN",  # Hindi
+    "kn-IN",  # Kannada
+    "ml-IN",  # Malayalam
+    "mr-IN",  # Marathi
+    "od-IN",  # Odia
+    "pa-IN",  # Punjabi
+    "ta-IN",  # Tamil
+    "te-IN",  # Telugu
+]
+
+SarvamTTSSpeakers = Literal[
+    # bulbul:v2 Female (lowercase)
+    "anushka",
+    "manisha",
+    "vidya",
+    "arya",
+    # bulbul:v2 Male (lowercase)
+    "abhilash",
+    "karun",
+    "hitesh",
+]
+
+# Model-Speaker compatibility mapping
+MODEL_SPEAKER_COMPATIBILITY = {
+    "bulbul:v2": {
+        "female": ["anushka", "manisha", "vidya", "arya"],
+        "male": ["abhilash", "karun", "hitesh"],
+        "all": ["anushka", "manisha", "vidya", "arya", "abhilash", "karun", "hitesh"],
+    },
+}
+
+
+def validate_model_speaker_compatibility(model: str, speaker: str) -> bool:
+    """Validate that the speaker is compatible with the model version."""
+    if model not in MODEL_SPEAKER_COMPATIBILITY:
+        logger.warning(f"Unknown model '{model}', skipping compatibility check")
+        return True
+
+    compatible_speakers = MODEL_SPEAKER_COMPATIBILITY[model]["all"]
+    if speaker.lower() not in compatible_speakers:
+        logger.error(
+            f"Speaker '{speaker}' is not compatible with model '{model}'. "
+            f"Compatible speakers for {model}: {', '.join(compatible_speakers)}"
+        )
+        return False
+    return True
+
+
+@dataclass
+class SarvamTTSOptions:
+    """Options for the Sarvam.ai TTS service.
+
+    Args:
+        target_language_code: BCP-47 language code for supported Indian languages
+        api_key: Sarvam.ai API key
+        text: The text to synthesize (will be provided by stream adapter)
+        speaker: Voice to use for synthesis
+        pitch: Voice pitch adjustment (-20.0 to 20.0)
+        pace: Speech rate multiplier (0.5 to 2.0)
+        loudness: Volume multiplier (0.5 to 2.0)
+        speech_sample_rate: Audio sample rate (8000, 16000, 22050, or 24000)
+        enable_preprocessing: Whether to use text preprocessing
+        model: The Sarvam TTS model to use
+        base_url: API endpoint URL
+    """
+
+    target_language_code: SarvamTTSLanguages | str  # BCP-47 for supported Indian languages
+    api_key: str  # Sarvam.ai API key
+    text: str | None = None  # Will be provided by the stream adapter
+    speaker: SarvamTTSSpeakers | str = "manisha"  # Default speaker compatible with v2
+    pitch: float = 0.0
+    pace: float = 1.0
+    loudness: float = 1.0
+    speech_sample_rate: int = 22050  # Default 22050 Hz
+    enable_preprocessing: bool = False
+    model: SarvamTTSModels | str = "bulbul:v2"  # Default to v2 as it has more recent speakers
+    base_url: str = SARVAM_TTS_BASE_URL
+
+
+class TTS(tts.TTS):
+    """Sarvam.ai Text-to-Speech implementation.
+
+    This class provides text-to-speech functionality using the Sarvam.ai API.
+    Sarvam.ai specializes in high-quality TTS for Indian languages.
+
+    Args:
+        target_language_code: BCP-47 language code for supported Indian languages
+        model: Sarvam TTS model to use (only bulbul:v2 supported)
+        speaker: Voice to use for synthesis
+        speech_sample_rate: Audio sample rate in Hz
+        num_channels: Number of audio channels (Sarvam outputs mono)
+        pitch: Voice pitch adjustment (-20.0 to 20.0)
+        pace: Speech rate multiplier (0.5 to 2.0)
+        loudness: Volume multiplier (0.5 to 2.0)
+        enable_preprocessing: Whether to use text preprocessing
+        api_key: Sarvam.ai API key (required)
+        base_url: API endpoint URL
+        http_session: Optional aiohttp session to use
+    """
+
+    def __init__(
+        self,
+        *,
+        target_language_code: SarvamTTSLanguages | str,
+        model: SarvamTTSModels | str = "bulbul:v2",
+        speaker: SarvamTTSSpeakers | str = "manisha",
+        speech_sample_rate: int = 22050,
+        num_channels: int = 1,  # Sarvam output is mono WAV
+        pitch: float = 0.0,
+        pace: float = 1.0,
+        loudness: float = 1.0,
+        enable_preprocessing: bool = False,
+        api_key: str,
+        base_url: str = SARVAM_TTS_BASE_URL,
+        http_session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        super().__init__(
+            capabilities=tts.TTSCapabilities(streaming=False),
+            sample_rate=speech_sample_rate,
+            num_channels=num_channels,
+        )
+
+        self._api_key = api_key or os.environ.get("SARVAM_API_KEY")
+        if not self._api_key:
+            raise ValueError(
+                "Sarvam API key is required. Provide it directly or set SARVAM_API_KEY env var."
+            )
+
+        # Validate model-speaker compatibility
+        if not validate_model_speaker_compatibility(model, speaker):
+            compatible_speakers = MODEL_SPEAKER_COMPATIBILITY.get(model, {}).get("all", [])
+            raise ValueError(
+                f"Speaker '{speaker}' is not compatible with model '{model}'. "
+                f"Please choose a compatible speaker from: {', '.join(compatible_speakers)}"
+            )
+
+        self._opts = SarvamTTSOptions(
+            target_language_code=target_language_code,
+            model=model,
+            speaker=speaker,
+            speech_sample_rate=speech_sample_rate,
+            pitch=pitch,
+            pace=pace,
+            loudness=loudness,
+            enable_preprocessing=enable_preprocessing,
+            api_key=self._api_key,
+            base_url=base_url,
+        )
+        self._session = http_session
+
+    def _ensure_session(self) -> aiohttp.ClientSession:
+        if not self._session:
+            self._session = utils.http_context.http_session()
+        return self._session
+
+    # Implement the abstract synthesize method
+    def synthesize(
+        self, text: str, *, conn_options: APIConnectOptions | None = None
+    ) -> ChunkedStream:
+        """Synthesize text to audio using Sarvam.ai TTS API."""
+        if conn_options is None:
+            conn_options = DEFAULT_API_CONNECT_OPTIONS
+        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:
+        """Run the Sarvam.ai TTS request and emit audio via the output emitter."""
+        payload = {
+            "target_language_code": self._opts.target_language_code,
+            "text": self._input_text,
+            "speaker": self._opts.speaker,
+            "pitch": self._opts.pitch,
+            "pace": self._opts.pace,
+            "loudness": self._opts.loudness,
+            "speech_sample_rate": self._opts.speech_sample_rate,
+            "enable_preprocessing": self._opts.enable_preprocessing,
+            "model": self._opts.model,
+        }
+        headers = {
+            "api-subscription-key": self._opts.api_key,
+            "Content-Type": "application/json",
+        }
+        try:
+            async with self._tts._ensure_session().post(
+                url=self._opts.base_url,
+                json=payload,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(
+                    total=self._conn_options.timeout,
+                    sock_connect=self._conn_options.timeout,
+                ),
+            ) as res:
+                if res.status != 200:
+                    error_text = await res.text()
+                    logger.error(f"Sarvam TTS API error: {res.status} - {error_text}")
+                    raise APIStatusError(
+                        message=f"Sarvam TTS API Error: {error_text}", status_code=res.status
+                    )
+
+                response_json = await res.json()
+                request_id = response_json.get("request_id", "")
+                audios = response_json.get("audios", [])
+                if not audios or not isinstance(audios, list):
+                    raise APIConnectionError("Sarvam TTS API response invalid: no audio data")
+
+                wav_bytes = base64.b64decode(audios[0])
+                output_emitter.initialize(
+                    request_id=request_id or "unknown",
+                    sample_rate=self._tts.sample_rate,
+                    num_channels=self._tts.num_channels,
+                    mime_type="audio/wav",
+                )
+                output_emitter.push(wav_bytes)
+        except asyncio.TimeoutError as e:
+            raise APITimeoutError("Sarvam TTS API request timed out") from e
+        except aiohttp.ClientError as e:
+            raise APIConnectionError(f"Sarvam TTS API connection error: {e}") from e

livekit_plugins_sarvam-1.1.0/livekit/plugins/sarvam/version.py

@@ -0,0 +1,15 @@
+# Copyright 2025 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.
+
+__version__ = "1.1.0"

livekit_plugins_sarvam-1.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "livekit-plugins-sarvam"
+dynamic = ["version"]
+description = "Agent Framework plugin for services using Sarvam.ai's API."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.9.0"
+authors = [{ name = "LiveKit", email = "hello@livekit.io" }]
+keywords = ["webrtc", "realtime", "audio", "video", "livekit", "sarvam", "indian-languages", "indic", "tts", "stt"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = ["livekit-agents[codecs]>=1.1.0", "numpy>=1.26"]
+
+[project.urls]
+Documentation = "https://docs.livekit.io"
+Website = "https://livekit.io/"
+Source = "https://github.com/livekit/agents"
+
+[tool.hatch.version]
+path = "livekit/plugins/sarvam/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["livekit"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/livekit"]