livekit-plugins-chariot 0.1.0__py3-none-any.whl

livekit/plugins/chariot/__init__.py

@@ -0,0 +1,62 @@
+# Copyright 2026 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.
+
+"""Chariot plugin for LiveKit Agents
+
+Support for speech-to-text and text-to-speech with [Chariot](https://chariot.in/), for English
+and Indian languages, including code-mixed speech.
+
+See https://docs.chariot.in/api-reference/introduction for more information.
+"""
+
+from .models import STTLanguages, STTModels, STTModes, STTStyles, TTSModels
+from .stt import STT, SpeechStream, VADOptions
+from .tts import TTS, ChunkedStream, SynthesizeStream
+from .version import __version__
+
+__all__ = [
+    "STT",
+    "SpeechStream",
+    "VADOptions",
+    "TTS",
+    "ChunkedStream",
+    "SynthesizeStream",
+    "STTLanguages",
+    "STTModels",
+    "STTModes",
+    "STTStyles",
+    "TTSModels",
+    "__version__",
+]
+
+from livekit.agents import Plugin
+
+from .log import logger
+
+
+class ChariotPlugin(Plugin):
+    def __init__(self) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+
+
+Plugin.register_plugin(ChariotPlugin())
+
+# 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/chariot/_utils.py

@@ -0,0 +1,116 @@
+# Copyright 2026 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 json
+import os
+
+import aiohttp
+
+from livekit.agents import APIConnectionError, APIError, APIStatusError
+
+from .version import __version__
+
+BASE_URL = "https://api.chariot.in"
+API_KEY_HEADER = "chariotai-api-key"
+USER_AGENT = f"LiveKit Agents Chariot Plugin/{__version__}"
+
+# The WebSocket close codes the API uses, besides 1000 (normal).
+CLOSE_POLICY = 1008  # invalid key or parameters, idle timeout, a backlog limit
+CLOSE_SERVER_ERROR = 1011
+CLOSE_NO_CREDITS = 4402
+CLOSE_SESSION_LIMIT = 4413  # the session reached its maximum length
+CLOSE_BUSY = 4429  # every concurrent session the plan allows is in use
+
+# HTTP status for each WebSocket error code, so retries follow the usual 4xx/5xx rules.
+_ERROR_STATUS = {
+    "bad_request": 400,
+    "unknown_context": 400,
+    "context_closing": 400,
+    "session_closing": 400,
+    "text_too_long": 400,
+    "insufficient_credits": 402,
+    "forbidden": 403,
+    "idle_timeout": 408,
+    "voice_unavailable": 422,
+    "context_limit": 429,
+    "concurrency_limit": 429,
+    "upstream_error": 502,
+}
+
+# 1008 reasons that a fresh connection clears, as opposed to a refusal it would repeat.
+_TRANSIENT_POLICY_REASONS = ("idle", "pending audio", "pending commit")
+
+
+def resolve_api_key(api_key: str | None) -> str:
+    api_key = api_key or os.environ.get("CHARIOT_API_KEY")
+    if not api_key:
+        raise ValueError("Chariot API key required. Set CHARIOT_API_KEY or provide api_key.")
+    return api_key
+
+
+def headers(api_key: str) -> dict[str, str]:
+    return {API_KEY_HEADER: api_key, "User-Agent": USER_AGENT}
+
+
+def ws_base_url(base_url: str) -> str:
+    return base_url.replace("https://", "wss://", 1).replace("http://", "ws://", 1)
+
+
+def error_event(event: dict) -> APIError:
+    """An `error` message on a WebSocket.
+
+    A string `code` names a refused request on a connection that stays open. A numeric `code`
+    is the close code of a connection the server is about to close.
+    """
+    code = event.get("code")
+    message = str(event.get("message") or "Chariot API error")
+    if isinstance(code, int):
+        return close_error(code, message)
+    return APIStatusError(
+        message, status_code=_ERROR_STATUS.get(code or "", 500), body=code or None
+    )
+
+
+def close_error(code: int | None, reason: str) -> APIError:
+    """The error for a connection the server closed before the work was done."""
+    message = f"Chariot connection closed ({code}): {reason or 'no reason given'}"
+    if code == CLOSE_POLICY and reason.lower().startswith("unauthorized"):
+        return APIStatusError(message, status_code=401)
+    if code == CLOSE_NO_CREDITS:
+        return APIStatusError(message, status_code=402)
+    if code == CLOSE_BUSY:
+        return APIStatusError(message, status_code=429)
+    if code == CLOSE_POLICY and not any(r in reason.lower() for r in _TRANSIENT_POLICY_REASONS):
+        return APIStatusError(message, status_code=400)
+    return APIConnectionError(message)
+
+
+async def http_error(resp: aiohttp.ClientResponse, request_id: str | None = None) -> APIStatusError:
+    """An error response from an HTTP endpoint, which carries `{"statusCode", "message"}`."""
+    text = await resp.text()
+    message = text
+    try:
+        body = json.loads(text)
+        if isinstance(body, dict) and body.get("message"):
+            message = str(body["message"])
+    except ValueError:
+        pass
+    return APIStatusError(
+        message or "Chariot API error",
+        status_code=resp.status,
+        request_id=request_id,
+        body=text or None,
+    )

livekit/plugins/chariot/log.py

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

livekit/plugins/chariot/models.py

@@ -0,0 +1,19 @@
+from typing import Literal
+
+TTSModels = Literal["chariot-multilingual-v1", "chariot-v0"]
+
+STTModels = Literal["chariot-1-asr-realtime"]
+
+# Languages the speech-to-text model transcribes. Leave the language unset to detect it.
+STTLanguages = Literal["en", "hi", "bn", "gu", "kn", "ml", "mr", "or", "pa", "sa", "ta", "te"]
+
+# "balanced" favors latency. "high_accuracy" is more accurate (it writes numbers as digits,
+# for example); its interim transcripts update less often.
+STTModes = Literal["balanced", "high_accuracy"]
+
+# "codemix" writes each word in the script it is usually written in, so English words in
+# Hindi speech come out in Latin script. "native" writes everything in the language's script.
+STTStyles = Literal["codemix", "native"]
+
+# Mono 16-bit PCM rates the streaming API accepts.
+STTSampleRates = Literal[8000, 16000, 22050, 24000, 32000, 44100, 48000]