livekit-plugins-rumik-ai 0.1.1__tar.gz

livekit_plugins_rumik_ai-0.1.1/.gitignore

@@ -0,0 +1,26 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.venv/
+venv/
+
+# Tooling caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Env / secrets
+.env
+.env.local
+
+# Example output
+recordings/
+
+# OS / editor
+.DS_Store
+.idea/
+.vscode/

livekit_plugins_rumik_ai-0.1.1/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 2026 Rumik AI
+
+   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.

livekit_plugins_rumik_ai-0.1.1/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.4
+Name: livekit-plugins-rumik-ai
+Version: 0.1.1
+Summary: LiveKit Agents plugin for text-to-speech with Rumik AI (muga & mulberry).
+Project-URL: Homepage, https://rumik.ai/
+Project-URL: Source, https://github.com/rumik-ai/livekit-plugins-rumik-ai
+Project-URL: Issues, https://github.com/rumik-ai/livekit-plugins-rumik-ai/issues
+Project-URL: Documentation, https://docs.livekit.io/agents/integrations/tts/
+Author-email: Rumik AI <hello@rumik.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: audio,hinglish,livekit,realtime,rumik-ai,text-to-speech,tts,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.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10.0
+Requires-Dist: livekit-agents[codecs]<2,>=1.5
+Provides-Extra: dev
+Requires-Dist: aiohttp; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# livekit-plugins-rumik-ai
+
+[Rumik AI](https://rumik.ai/) text-to-speech plugin for [LiveKit Agents](https://github.com/livekit/agents).
+
+Streams low-latency 24 kHz speech from Rumik's **Silk** models over a reusable WebSocket
+session:
+
+- **muga** — emotion-controlled via a leading `[tone]` tag (e.g. `[happy]`, `[sad]`) plus
+  optional `<laugh>`/`<chuckle>`/`<sigh>` events. Tuned for Romanized Hinglish.
+- **mulberry** — steered by a natural-language voice `description` or a preset `speaker`,
+  with optional pitch shift (`f0_up_key`).
+
+## Install
+
+```bash
+pip install livekit-plugins-rumik-ai
+```
+
+This depends on `livekit-agents` (1.5+). Set your key:
+
+```bash
+export RUMIK_API_KEY="your-rumik-api-key"
+```
+
+## Quickstart
+
+```python
+from livekit.agents import AgentSession
+from livekit.plugins import rumik_ai
+
+# muga: the LLM should start each reply with one tone tag, e.g. "[happy] ..."
+session = AgentSession(
+    stt=...,
+    llm=...,
+    tts=rumik_ai.TTS(model="muga"),
+)
+```
+
+Mulberry, steered by a voice description (or a preset speaker):
+
+```python
+tts = rumik_ai.TTS(
+    model="mulberry",
+    description="warm, gentle female friend",
+    # speaker="speaker_1",      # optional preset, overrides description
+    # f0_up_key=2.0,            # optional pitch shift, -12..12 semitones
+)
+```
+
+### Changing the voice at runtime
+
+`description`, `speaker`, `f0_up_key`, and the sampling params are sent on **every
+request**, so you can change mulberry's voice between turns without reconnecting — the
+pooled WebSocket is reused (only a `model` change re-mints the session):
+
+```python
+tts.update_options(description="excited young man, fast and energetic")
+# the next synthesis request uses the new voice
+```
+
+## Latency vs. smoothness
+
+The default is model-aware:
+
+- **muga** buffers the full LLM reply and synthesizes it in one request, so its leading
+  `[tone]` tag conditions the whole utterance (and there are no per-request TTFB gaps).
+- **mulberry** streams sentence-by-sentence for lower time-to-first-word, since it has
+  no tone tag to protect.
+
+Override either with `full_response_aggregation`:
+
+```python
+rumik_ai.TTS(model="muga", full_response_aggregation=False, tone="neutral")  # muga, lower latency
+rumik_ai.TTS(model="mulberry", full_response_aggregation=True)               # mulberry, smoother
+```
+
+When you turn aggregation **off for muga**, set a fallback `tone=` so every sentence
+keeps a tone tag.
+
+## Configuration
+
+| Argument | Models | Notes |
+|---|---|---|
+| `model` | both | `"muga"` (default) or `"mulberry"` |
+| `tone` | muga | fallback tone when input is untagged |
+| `description` | mulberry | natural-language voice description |
+| `speaker` | mulberry | `speaker_1`..`speaker_4` |
+| `f0_up_key` | mulberry | pitch shift, `-12`..`12` |
+| `temperature`, `top_p`, `top_k`, `repetition_penalty`, `max_new_tokens` | both | omitted unless set (Rumik defaults apply) |
+| `full_response_aggregation` | both | buffer the full reply (`True`) vs. stream per sentence (`False`). Default: `True` for muga, `False` for mulberry |
+| `api_key` | — | defaults to `RUMIK_API_KEY` |
+| `base_url` | — | defaults to `https://silk-api.rumik.ai` |
+
+## Examples
+
+See [`examples/`](./examples) for a full voice agent (`rumik_ai_agent.py`) and a
+record-to-WAV demo (`rumik_ai_tts.py`).
+
+## License
+
+Apache-2.0

livekit_plugins_rumik_ai-0.1.1/README.md

@@ -0,0 +1,101 @@
+# livekit-plugins-rumik-ai
+
+[Rumik AI](https://rumik.ai/) text-to-speech plugin for [LiveKit Agents](https://github.com/livekit/agents).
+
+Streams low-latency 24 kHz speech from Rumik's **Silk** models over a reusable WebSocket
+session:
+
+- **muga** — emotion-controlled via a leading `[tone]` tag (e.g. `[happy]`, `[sad]`) plus
+  optional `<laugh>`/`<chuckle>`/`<sigh>` events. Tuned for Romanized Hinglish.
+- **mulberry** — steered by a natural-language voice `description` or a preset `speaker`,
+  with optional pitch shift (`f0_up_key`).
+
+## Install
+
+```bash
+pip install livekit-plugins-rumik-ai
+```
+
+This depends on `livekit-agents` (1.5+). Set your key:
+
+```bash
+export RUMIK_API_KEY="your-rumik-api-key"
+```
+
+## Quickstart
+
+```python
+from livekit.agents import AgentSession
+from livekit.plugins import rumik_ai
+
+# muga: the LLM should start each reply with one tone tag, e.g. "[happy] ..."
+session = AgentSession(
+    stt=...,
+    llm=...,
+    tts=rumik_ai.TTS(model="muga"),
+)
+```
+
+Mulberry, steered by a voice description (or a preset speaker):
+
+```python
+tts = rumik_ai.TTS(
+    model="mulberry",
+    description="warm, gentle female friend",
+    # speaker="speaker_1",      # optional preset, overrides description
+    # f0_up_key=2.0,            # optional pitch shift, -12..12 semitones
+)
+```
+
+### Changing the voice at runtime
+
+`description`, `speaker`, `f0_up_key`, and the sampling params are sent on **every
+request**, so you can change mulberry's voice between turns without reconnecting — the
+pooled WebSocket is reused (only a `model` change re-mints the session):
+
+```python
+tts.update_options(description="excited young man, fast and energetic")
+# the next synthesis request uses the new voice
+```
+
+## Latency vs. smoothness
+
+The default is model-aware:
+
+- **muga** buffers the full LLM reply and synthesizes it in one request, so its leading
+  `[tone]` tag conditions the whole utterance (and there are no per-request TTFB gaps).
+- **mulberry** streams sentence-by-sentence for lower time-to-first-word, since it has
+  no tone tag to protect.
+
+Override either with `full_response_aggregation`:
+
+```python
+rumik_ai.TTS(model="muga", full_response_aggregation=False, tone="neutral")  # muga, lower latency
+rumik_ai.TTS(model="mulberry", full_response_aggregation=True)               # mulberry, smoother
+```
+
+When you turn aggregation **off for muga**, set a fallback `tone=` so every sentence
+keeps a tone tag.
+
+## Configuration
+
+| Argument | Models | Notes |
+|---|---|---|
+| `model` | both | `"muga"` (default) or `"mulberry"` |
+| `tone` | muga | fallback tone when input is untagged |
+| `description` | mulberry | natural-language voice description |
+| `speaker` | mulberry | `speaker_1`..`speaker_4` |
+| `f0_up_key` | mulberry | pitch shift, `-12`..`12` |
+| `temperature`, `top_p`, `top_k`, `repetition_penalty`, `max_new_tokens` | both | omitted unless set (Rumik defaults apply) |
+| `full_response_aggregation` | both | buffer the full reply (`True`) vs. stream per sentence (`False`). Default: `True` for muga, `False` for mulberry |
+| `api_key` | — | defaults to `RUMIK_API_KEY` |
+| `base_url` | — | defaults to `https://silk-api.rumik.ai` |
+
+## Examples
+
+See [`examples/`](./examples) for a full voice agent (`rumik_ai_agent.py`) and a
+record-to-WAV demo (`rumik_ai_tts.py`).
+
+## License
+
+Apache-2.0

livekit_plugins_rumik_ai-0.1.1/livekit/plugins/rumik_ai/__init__.py

@@ -0,0 +1,46 @@
+# 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.
+
+"""Rumik AI plugin for LiveKit Agents.
+
+Support for low-latency text-to-speech with Rumik AI Silk models.
+
+For API access, visit https://rumik.ai/
+"""
+
+from .tts import TTS
+from .version import __version__
+
+__all__ = ["TTS", "__version__"]
+
+from livekit.agents import Plugin
+
+from .log import logger
+
+
+class RumikAIPlugin(Plugin):
+    def __init__(self) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+
+
+Plugin.register_plugin(RumikAIPlugin())
+
+# 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_rumik_ai-0.1.1/livekit/plugins/rumik_ai/log.py

@@ -0,0 +1,17 @@
+# 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.
+
+import logging
+
+logger = logging.getLogger("livekit.plugins.rumik_ai")

livekit_plugins_rumik_ai-0.1.1/livekit/plugins/rumik_ai/py.typed

@@ -0,0 +1 @@
+

livekit_plugins_rumik_ai-0.1.1/livekit/plugins/rumik_ai/tts.py

@@ -0,0 +1,715 @@
+# 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 asyncio
+import json
+import os
+import re
+import weakref
+from collections.abc import Callable
+from dataclasses import dataclass, replace
+from typing import Any, Literal, cast
+from urllib.parse import quote
+
+import aiohttp
+
+from livekit.agents import (
+    APIConnectionError,
+    APIConnectOptions,
+    APIStatusError,
+    APITimeoutError,
+    create_api_error_from_http,
+    tts,
+    utils,
+)
+from livekit.agents.types import DEFAULT_API_CONNECT_OPTIONS, NOT_GIVEN, NotGivenOr
+from livekit.agents.utils import is_given
+
+from .log import logger
+
+Model = Literal["muga", "mulberry"]
+MugaTone = Literal["happy", "excited", "sad", "angry", "neutral", "whisper"]
+MulberrySpeaker = Literal["speaker_1", "speaker_2", "speaker_3", "speaker_4"]
+
+DEFAULT_BASE_URL = "https://silk-api.rumik.ai"
+DEFAULT_SAMPLE_RATE = 24000
+NUM_CHANNELS = 1
+MAX_TEXT_LENGTH = 2000
+
+# Text used only to mint a reusable WebSocket session. The real text is sent per
+# synthesis request over the same socket, so this value is never synthesized.
+_INIT_TEXT = "init"
+# Backstop cap on a pooled session's age. Heartbeat pings (see _WS_HEARTBEAT) keep
+# the socket warm so Rumik rarely idle-closes it between turns, and stale sockets are
+# still detected on checkout and re-minted -- so this is only a safety cap, not the
+# primary refresh mechanism.
+_MAX_SESSION_DURATION = 300.0
+# aiohttp sends a WebSocket ping every _WS_HEARTBEAT seconds and drops the socket if
+# no pong returns. This keeps the reused session alive across conversational pauses so
+# the next turn does not pay a fresh mint, mirroring the Rumik Pipecat integration.
+_WS_HEARTBEAT = 20.0
+
+MUGA_TONES = {"happy", "excited", "sad", "angry", "neutral", "whisper"}
+MUGA_EVENTS = {"laugh", "chuckle", "sigh"}
+MUGA_EVENT_COMPATIBILITY = {
+    "happy": {"laugh", "chuckle"},
+    "excited": {"laugh", "chuckle"},
+    "sad": {"sigh"},
+    "angry": {"sigh"},
+    "neutral": {"laugh", "sigh"},
+    "whisper": {"chuckle", "sigh"},
+}
+MULBERRY_SPEAKERS = {"speaker_1", "speaker_2", "speaker_3", "speaker_4"}
+
+_SQUARE_TAG_RE = re.compile(r"\[([^\]]+)\]")
+_TONE_PREFIX_RE = re.compile(r"^\[([^\]]+)\](.*)$", re.DOTALL)
+_EVENT_TAG_RE = re.compile(r"<([^>]+)>")
+_DEVANAGARI_RE = re.compile(r"[\u0900-\u097F]")
+
+
+class _StaleConnectionError(Exception):
+    """Raised when a pooled WebSocket is found closed; triggers a reconnect."""
+
+
+@dataclass
+class _TTSOptions:
+    model: Model | str
+    api_key: str
+    tone: MugaTone | str | None
+    description: NotGivenOr[str]
+    speaker: NotGivenOr[MulberrySpeaker | str]
+    f0_up_key: NotGivenOr[float]
+    temperature: NotGivenOr[float]
+    top_p: NotGivenOr[float]
+    top_k: NotGivenOr[int]
+    repetition_penalty: NotGivenOr[float]
+    max_new_tokens: NotGivenOr[int]
+    base_url: str
+
+
+class TTS(tts.TTS):
+    def __init__(
+        self,
+        *,
+        model: Model | str = "muga",
+        tone: MugaTone | str | None = None,
+        description: NotGivenOr[str] = NOT_GIVEN,
+        speaker: NotGivenOr[MulberrySpeaker | str] = NOT_GIVEN,
+        f0_up_key: NotGivenOr[float] = NOT_GIVEN,
+        temperature: NotGivenOr[float] = NOT_GIVEN,
+        top_p: NotGivenOr[float] = NOT_GIVEN,
+        top_k: NotGivenOr[int] = NOT_GIVEN,
+        repetition_penalty: NotGivenOr[float] = NOT_GIVEN,
+        max_new_tokens: NotGivenOr[int] = NOT_GIVEN,
+        full_response_aggregation: NotGivenOr[bool] = NOT_GIVEN,
+        api_key: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        http_session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        """Create a Rumik AI text-to-speech client.
+
+        The client maintains a reusable Rumik WebSocket session: it mints the
+        session once and streams every synthesis request over the same socket,
+        re-minting only when the socket goes stale. By default ``muga`` buffers the full
+        LLM response and synthesizes it in one request so its leading ``[tone]`` tag
+        conditions the whole utterance; ``mulberry`` has no tone tag, so it streams
+        sentence-by-sentence for lower latency (see ``full_response_aggregation``).
+
+        Args:
+            model: Rumik AI Silk model to use. Supports ``"muga"`` and ``"mulberry"``.
+            tone: Optional Muga fallback tone. When omitted, each Muga input must already
+                start with a valid tone tag such as ``[happy]`` or ``[sad]``. When provided,
+                untagged input is prefixed with this tone, and existing tags must match it.
+            description: Mulberry-only natural language voice description.
+            speaker: Optional Mulberry preset speaker, ``speaker_1`` through ``speaker_4``.
+            f0_up_key: Mulberry-only pitch shift in semitones, from -12 to 12.
+            temperature: Optional sampling temperature. Omitted unless set, so Rumik AI
+                applies its own default.
+            top_p: Optional nucleus sampling value. Omitted unless set.
+            top_k: Optional top-k sampling value. Omitted unless set.
+            repetition_penalty: Optional penalty for repeated tokens. Omitted unless set.
+            max_new_tokens: Optional output length cap. Omitted unless set.
+            full_response_aggregation: When True, buffer the complete LLM response and
+                synthesize it in one request to avoid sentence-level TTFB gaps. When
+                False, stream sentence-by-sentence via the framework's StreamAdapter for
+                lower latency; with muga, set a fallback ``tone`` so each sentence keeps
+                a tone tag. Defaults to True for muga (its ``[tone]`` tag must condition
+                the whole utterance) and False for mulberry (lower latency).
+            api_key: Rumik AI API key. If not provided, reads ``RUMIK_API_KEY``.
+            base_url: Rumik AI API base URL.
+            http_session: Existing aiohttp session to use.
+        """
+        # muga buffers the full LLM response and synthesizes it in one request
+        # (streaming=True) so its leading [tone] tag conditions the whole utterance and
+        # there are no audible gaps from Rumik's per-request TTFB. mulberry has no tone
+        # tag, so by default it streams sentence-by-sentence via the framework's
+        # StreamAdapter for lower time-to-first-word. An explicit value always wins.
+        if is_given(full_response_aggregation):
+            full_aggregation = full_response_aggregation
+        else:
+            full_aggregation = model != "mulberry"
+
+        super().__init__(
+            capabilities=tts.TTSCapabilities(streaming=full_aggregation, aligned_transcript=False),
+            sample_rate=DEFAULT_SAMPLE_RATE,
+            num_channels=NUM_CHANNELS,
+        )
+
+        api_key = api_key or os.environ.get("RUMIK_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "Rumik AI API key is required, either as argument or set RUMIK_API_KEY"
+            )
+
+        opts = _TTSOptions(
+            model=model,
+            api_key=api_key,
+            tone=tone,
+            description=description,
+            speaker=speaker,
+            f0_up_key=f0_up_key,
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            repetition_penalty=repetition_penalty,
+            max_new_tokens=max_new_tokens,
+            base_url=base_url.rstrip("/"),
+        )
+        _validate_options(opts)
+
+        self._opts = opts
+        self._session = http_session
+        self._streams = weakref.WeakSet[SynthesizeStream]()
+        # Mint the Rumik session once and reuse the socket across requests/turns.
+        self._pool = utils.ConnectionPool[aiohttp.ClientWebSocketResponse](
+            connect_cb=self._connect_ws,
+            close_cb=self._close_ws,
+            max_session_duration=_MAX_SESSION_DURATION,
+        )
+
+    @property
+    def model(self) -> str:
+        return self._opts.model
+
+    @property
+    def provider(self) -> str:
+        return "Rumik AI"
+
+    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:
+        ws_url = await self._mint_ws_session(timeout)
+
+        async def _open() -> aiohttp.ClientWebSocketResponse:
+            ws = await self._ensure_session().ws_connect(ws_url, heartbeat=_WS_HEARTBEAT)
+            # aiohttp's overloads narrow the autoping type param to ``bool`` when
+            # ``heartbeat`` is passed; at runtime autoping stays True, so normalize.
+            return cast(aiohttp.ClientWebSocketResponse, ws)
+
+        try:
+            return await asyncio.wait_for(_open(), timeout)
+        except asyncio.TimeoutError:
+            raise APITimeoutError() from None
+        except Exception as e:
+            raise APIConnectionError() from e
+
+    async def _close_ws(self, ws: aiohttp.ClientWebSocketResponse) -> None:
+        # Tell Rumik we're done so it can release the session, then close. Best-effort:
+        # the socket may already be gone (idle timeout, server close, interruption).
+        try:
+            if not ws.closed:
+                await ws.send_str(json.dumps({"type": "close"}))
+        except Exception:
+            pass
+        await ws.close()
+
+    async def _mint_ws_session(self, timeout: float) -> str:
+        try:
+            async with self._ensure_session().post(
+                f"{self._opts.base_url}/v1/tts/ws-connect",
+                headers={"Authorization": f"Bearer {self._opts.api_key}"},
+                json={"model": self._opts.model, "text": _INIT_TEXT},
+                timeout=aiohttp.ClientTimeout(total=timeout),
+            ) as resp:
+                body = await _read_response_body(resp)
+                if resp.status >= 400:
+                    message = _error_message(body)
+                    raise create_api_error_from_http(message, status=resp.status, body=body)
+
+                if not isinstance(body, dict):
+                    raise APIStatusError(
+                        "Rumik AI ws-connect returned a non-JSON response",
+                        status_code=resp.status,
+                        body=body,
+                        retryable=False,
+                    )
+
+                ws_url = body.get("ws_url")
+                token = body.get("token")
+                if not isinstance(ws_url, str) or not isinstance(token, str):
+                    raise APIStatusError(
+                        "Rumik AI ws-connect response is missing ws_url or token",
+                        status_code=resp.status,
+                        body=body,
+                        retryable=False,
+                    )
+
+                separator = "&" if "?" in ws_url else "?"
+                return f"{ws_url}{separator}token={quote(token)}"
+        except asyncio.TimeoutError:
+            raise APITimeoutError() from None
+        except APIStatusError:
+            raise
+        except Exception as e:
+            raise APIConnectionError() from e
+
+    def update_options(
+        self,
+        *,
+        model: NotGivenOr[Model | str] = NOT_GIVEN,
+        tone: NotGivenOr[MugaTone | str | None] = NOT_GIVEN,
+        description: NotGivenOr[str] = NOT_GIVEN,
+        speaker: NotGivenOr[MulberrySpeaker | str] = NOT_GIVEN,
+        f0_up_key: NotGivenOr[float] = NOT_GIVEN,
+        temperature: NotGivenOr[float] = NOT_GIVEN,
+        top_p: NotGivenOr[float] = NOT_GIVEN,
+        top_k: NotGivenOr[int] = NOT_GIVEN,
+        repetition_penalty: NotGivenOr[float] = NOT_GIVEN,
+        max_new_tokens: NotGivenOr[int] = NOT_GIVEN,
+    ) -> None:
+        """Update TTS options.
+
+        Options are sent on each synthesis request, so changes take effect on the next
+        request without reconnecting -- handy for varying mulberry's ``description``,
+        ``speaker``, or ``f0_up_key`` between turns. Changing ``model`` is the exception:
+        the model is pinned when the WebSocket session is minted, so it invalidates the
+        pooled connection and the next request re-mints.
+        """
+        opts = replace(self._opts)
+        model_changed = False
+        if is_given(model):
+            model_changed = model != opts.model
+            opts.model = model
+        if is_given(tone):
+            opts.tone = tone
+        if is_given(description):
+            opts.description = description
+        if is_given(speaker):
+            opts.speaker = speaker
+        if is_given(f0_up_key):
+            opts.f0_up_key = f0_up_key
+        if is_given(temperature):
+            opts.temperature = temperature
+        if is_given(top_p):
+            opts.top_p = top_p
+        if is_given(top_k):
+            opts.top_k = top_k
+        if is_given(repetition_penalty):
+            opts.repetition_penalty = repetition_penalty
+        if is_given(max_new_tokens):
+            opts.max_new_tokens = max_new_tokens
+
+        _validate_options(opts)
+        self._opts = opts
+        if model_changed:
+            # The model is fixed at mint time, so existing pooled sockets are stale.
+            self._pool.invalidate()
+
+    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
+
+    def prewarm(self) -> None:
+        """Open the Rumik WebSocket session ahead of the first request."""
+        self._pool.prewarm()
+
+    async def aclose(self) -> None:
+        for stream in list(self._streams):
+            await stream.aclose()
+        self._streams.clear()
+        await self._pool.aclose()
+
+    async def _stream_synthesis(
+        self,
+        text: str,
+        opts: _TTSOptions,
+        conn_options: APIConnectOptions,
+        output_emitter: tts.AudioEmitter,
+        *,
+        on_started: Callable[[], None] | None = None,
+    ) -> None:
+        """Synthesize one request over the pooled WebSocket and push PCM out.
+
+        Shared by SynthesizeStream (full-response mode: one request for the whole
+        reply) and ChunkedStream (per-sentence StreamAdapter mode, or a
+        FallbackAdapter: one request per fixed piece of text).
+        """
+        try:
+            prepared_text = _prepare_text(text, opts)
+            payload = _synthesis_payload(prepared_text, opts)
+
+            # Reconnect-on-stale: a pooled socket may have been idle-closed by Rumik.
+            # Detect that before sending and re-mint a fresh session once.
+            for attempt in range(2):
+                try:
+                    async with self._pool.connection(timeout=conn_options.timeout) as ws:
+                        if ws.closed:
+                            raise _StaleConnectionError
+                        await self._stream_on_ws(
+                            ws, payload, conn_options, output_emitter, on_started
+                        )
+                    return
+                except _StaleConnectionError:
+                    if attempt == 1:
+                        raise APIConnectionError("Rumik AI WebSocket is unavailable") from None
+        except asyncio.TimeoutError:
+            raise APITimeoutError() from None
+        except (APIConnectionError, APIStatusError, APITimeoutError):
+            raise
+        except aiohttp.ClientResponseError as e:
+            raise APIStatusError(message=e.message, status_code=e.status, body=None) from None
+        except Exception as e:
+            raise APIConnectionError() from e
+
+    async def _stream_on_ws(
+        self,
+        ws: aiohttp.ClientWebSocketResponse,
+        payload: dict[str, Any],
+        conn_options: APIConnectOptions,
+        output_emitter: tts.AudioEmitter,
+        on_started: Callable[[], None] | None,
+    ) -> None:
+        if on_started is not None:
+            on_started()
+        await ws.send_str(json.dumps(payload))
+
+        received_audio = False
+        while True:
+            msg = await ws.receive(timeout=conn_options.timeout)
+            if msg.type == aiohttp.WSMsgType.BINARY:
+                received_audio = True
+                output_emitter.push(msg.data)
+            elif msg.type == aiohttp.WSMsgType.TEXT:
+                event = _loads_event(msg.data)
+                event_type = event.get("type")
+                if event_type == "done":
+                    # rtf > 1.0 means Rumik generated slower than real time, which can
+                    # starve playback and sound robotic; surface it for diagnosis.
+                    logger.debug(
+                        "Rumik AI TTS synthesis complete",
+                        extra={
+                            "audio_duration": event.get("audio_duration"),
+                            "rtf": event.get("rtf"),
+                        },
+                    )
+                    return
+                if event_type == "error" or "error" in event:
+                    raise _provider_error(event)
+                if event_type == "timeout":
+                    # Server idle-closed the session; the pool evicts it on the raise.
+                    raise APIConnectionError("Rumik AI WebSocket idle timeout")
+                # "queued" and any other informational events are ignored.
+                logger.debug("Ignoring Rumik AI TTS event", extra={"event": event})
+            elif msg.type == aiohttp.WSMsgType.ERROR:
+                raise APIConnectionError(f"Rumik AI WebSocket error: {ws.exception()!r}")
+            elif msg.type in (
+                aiohttp.WSMsgType.CLOSE,
+                aiohttp.WSMsgType.CLOSED,
+                aiohttp.WSMsgType.CLOSING,
+            ):
+                close_code = getattr(ws, "close_code", None) or getattr(msg, "data", None)
+                # The server closed the socket, so it cannot be reused.
+                self._pool.remove(ws)
+                if received_audio and close_code in (None, 1000):
+                    return
+                raise APIConnectionError(
+                    f"Rumik AI WebSocket closed unexpectedly: code={close_code!r}"
+                )
+
+
+class ChunkedStream(tts.ChunkedStream):
+    """One Rumik request for a fixed piece of text (a StreamAdapter sentence or fallback)."""
+
+    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:
+        output_emitter.initialize(
+            request_id=utils.shortuuid(),
+            sample_rate=DEFAULT_SAMPLE_RATE,
+            num_channels=NUM_CHANNELS,
+            mime_type="audio/pcm",
+        )
+        await self._tts._stream_synthesis(
+            self._input_text, self._opts, self._conn_options, output_emitter
+        )
+
+
+class SynthesizeStream(tts.SynthesizeStream):
+    """Synthesizes the full LLM response as a single Rumik request (one segment)."""
+
+    def __init__(self, *, tts: TTS, conn_options: APIConnectOptions) -> None:
+        super().__init__(tts=tts, conn_options=conn_options)
+        self._tts: TTS = tts
+        self._opts = replace(tts._opts)
+
+    async def _run(self, output_emitter: tts.AudioEmitter) -> None:
+        output_emitter.initialize(
+            request_id=utils.shortuuid(),
+            sample_rate=DEFAULT_SAMPLE_RATE,
+            num_channels=NUM_CHANNELS,
+            mime_type="audio/pcm",
+            stream=True,
+        )
+
+        # The framework feeds one segment per stream, so we synthesize the whole
+        # response in a single request once the input is drained.
+        parts: list[str] = []
+        async for input_data in self._input_ch:
+            if isinstance(input_data, str):
+                parts.append(input_data)
+
+        text = "".join(parts).strip()
+        if not text:
+            return
+
+        output_emitter.start_segment(segment_id=utils.shortuuid())
+        try:
+            await self._tts._stream_synthesis(
+                text,
+                self._opts,
+                self._conn_options,
+                output_emitter,
+                on_started=self._mark_started,
+            )
+        finally:
+            output_emitter.end_segment()
+
+
+def _validate_options(opts: _TTSOptions) -> None:
+    if opts.model not in {"muga", "mulberry"}:
+        raise ValueError("Rumik AI model must be 'muga' or 'mulberry'")
+
+    if opts.model == "muga":
+        if opts.tone is not None and opts.tone not in MUGA_TONES:
+            raise ValueError(f"Unsupported Rumik AI Muga tone: {opts.tone}")
+        if is_given(opts.description):
+            raise ValueError("description is only supported with Rumik AI Mulberry")
+        if is_given(opts.speaker):
+            raise ValueError("speaker is only supported with Rumik AI Mulberry")
+        if is_given(opts.f0_up_key):
+            raise ValueError("f0_up_key is only supported with Rumik AI Mulberry")
+        return
+
+    if opts.tone is not None:
+        raise ValueError("tone is only supported with Rumik AI Muga")
+    if is_given(opts.speaker) and opts.speaker not in MULBERRY_SPEAKERS:
+        raise ValueError(
+            "Rumik AI Mulberry speaker must be speaker_1, speaker_2, speaker_3, or speaker_4"
+        )
+    if is_given(opts.f0_up_key) and not -12 <= opts.f0_up_key <= 12:
+        raise ValueError("Rumik AI Mulberry f0_up_key must be between -12 and 12")
+
+
+def _prepare_text(text: str, opts: _TTSOptions) -> str:
+    # Collapse every run of whitespace (including newlines from buffered LLM output)
+    # to a single space: Rumik gets clean text, and muga's "exactly one space after
+    # the [tone] tag" rule holds even when the model emits a newline after the tag.
+    text = re.sub(r"\s+", " ", text).strip()
+    if not text:
+        raise ValueError("Rumik AI TTS text must not be empty")
+
+    if opts.model == "muga":
+        text = _prepare_muga_text(text, opts)
+    elif opts.model == "mulberry":
+        text = _prepare_mulberry_text(text)
+
+    if len(text) > MAX_TEXT_LENGTH:
+        raise ValueError("Rumik AI TTS text must be 2000 characters or fewer")
+
+    return text
+
+
+def _prepare_muga_text(text: str, opts: _TTSOptions) -> str:
+    if _DEVANAGARI_RE.search(text):
+        raise ValueError("Rumik AI Muga expects Hinglish in Roman script")
+
+    square_tags = _SQUARE_TAG_RE.findall(text)
+    if len(square_tags) > 1:
+        raise ValueError("Rumik AI Muga text must contain exactly one global tone tag")
+
+    tone = opts.tone
+    match = _TONE_PREFIX_RE.match(text)
+    if match:
+        text_tone = match.group(1)
+        after_tag = match.group(2)
+        if text_tone not in MUGA_TONES:
+            raise ValueError(f"Unsupported Rumik AI Muga tone tag: [{text_tone}]")
+        if tone is not None and text_tone != tone:
+            raise ValueError("Rumik AI Muga text tone tag must match the configured tone")
+        if not after_tag.startswith(" "):
+            raise ValueError("Rumik AI Muga tone tag must be followed by one space")
+        tone = text_tone
+    elif square_tags:
+        raise ValueError("Rumik AI Muga tone tag must be at the start of the text")
+    else:
+        if tone is None:
+            raise ValueError(
+                "Rumik AI Muga text must start with one global tone tag "
+                "when no fallback tone is configured"
+            )
+        text = f"[{tone}] {text}"
+
+    assert tone is not None
+    events = _EVENT_TAG_RE.findall(text)
+    for event in events:
+        if event not in MUGA_EVENTS:
+            raise ValueError(f"Unsupported Rumik AI Muga event tag: <{event}>")
+        if event not in MUGA_EVENT_COMPATIBILITY[tone]:
+            raise ValueError(f"Rumik AI Muga event <{event}> is not compatible with [{tone}]")
+
+    if _has_too_many_stacked_events(text):
+        raise ValueError("Rumik AI Muga supports at most two stacked event tags")
+
+    return text
+
+
+def _prepare_mulberry_text(text: str) -> str:
+    match = _TONE_PREFIX_RE.match(text)
+    if match and match.group(1) in MUGA_TONES:
+        raise ValueError("Rumik AI Mulberry does not support Muga tone tags")
+
+    events = _EVENT_TAG_RE.findall(text)
+    unsupported_events = sorted(event for event in events if event in MUGA_EVENTS)
+    if unsupported_events:
+        raise ValueError("Rumik AI Mulberry does not support Muga event tags")
+
+    return text
+
+
+def _has_too_many_stacked_events(text: str) -> bool:
+    consecutive = 0
+    last_end = -1
+    for match in _EVENT_TAG_RE.finditer(text):
+        if match.group(1) not in MUGA_EVENTS:
+            consecutive = 0
+            last_end = match.end()
+            continue
+
+        between = text[last_end : match.start()] if last_end >= 0 else ""
+        if last_end >= 0 and between.strip() == "":
+            consecutive += 1
+        else:
+            consecutive = 1
+        if consecutive > 2:
+            return True
+        last_end = match.end()
+
+    return False
+
+
+def _synthesis_payload(text: str, opts: _TTSOptions) -> dict[str, Any]:
+    # The model is fixed when the session is minted, so it is not resent here. Only
+    # explicitly-set parameters are included; Rumik AI applies its own defaults for
+    # the rest.
+    payload: dict[str, Any] = {"text": text}
+
+    if is_given(opts.description):
+        payload["description"] = opts.description
+    if is_given(opts.speaker):
+        payload["speaker"] = opts.speaker
+    if is_given(opts.f0_up_key):
+        payload["f0_up_key"] = opts.f0_up_key
+    if is_given(opts.temperature):
+        payload["temperature"] = opts.temperature
+    if is_given(opts.top_p):
+        payload["top_p"] = opts.top_p
+    if is_given(opts.top_k):
+        payload["top_k"] = opts.top_k
+    if is_given(opts.repetition_penalty):
+        payload["repetition_penalty"] = opts.repetition_penalty
+    if is_given(opts.max_new_tokens):
+        payload["max_new_tokens"] = opts.max_new_tokens
+
+    return payload
+
+
+async def _read_response_body(resp: aiohttp.ClientResponse) -> object:
+    try:
+        return await resp.json()
+    except Exception:
+        return await resp.text()
+
+
+def _loads_event(data: str) -> dict[str, Any]:
+    try:
+        event = json.loads(data)
+    except json.JSONDecodeError as e:
+        raise APIConnectionError("Rumik AI WebSocket returned invalid JSON") from e
+    if not isinstance(event, dict):
+        raise APIConnectionError("Rumik AI WebSocket returned an invalid event")
+    return event
+
+
+def _provider_error(event: dict[str, Any]) -> APIStatusError:
+    message = _error_message(event)
+    status_code = _event_status_code(event)
+    return APIStatusError(
+        message=f"Rumik AI TTS error: {message}",
+        status_code=status_code,
+        body=event,
+        retryable=status_code in (408, 429, 499, 503),
+    )
+
+
+def _error_message(body: object) -> str:
+    if isinstance(body, dict):
+        error = body.get("error")
+        code = body.get("code")
+        if error and code:
+            return f"{error} ({code})"
+        if error:
+            return str(error)
+    if isinstance(body, str) and body:
+        return body
+    return "Rumik AI request failed"
+
+
+def _event_status_code(event: dict[str, Any]) -> int:
+    status = event.get("status") or event.get("status_code")
+    if isinstance(status, int):
+        return status
+    if isinstance(status, str) and status.isdecimal():
+        return int(status)
+    return -1

livekit_plugins_rumik_ai-0.1.1/livekit/plugins/rumik_ai/version.py

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

livekit_plugins_rumik_ai-0.1.1/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "livekit-plugins-rumik-ai"
+dynamic = ["version"]
+description = "LiveKit Agents plugin for text-to-speech with Rumik AI (muga & mulberry)."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+requires-python = ">=3.10.0"
+authors = [{ name = "Rumik AI", email = "hello@rumik.ai" }]
+keywords = [
+    "webrtc",
+    "realtime",
+    "audio",
+    "livekit",
+    "rumik-ai",
+    "tts",
+    "text-to-speech",
+    "hinglish",
+]
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = ["livekit-agents[codecs]>=1.5,<2"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.23", "aiohttp", "ruff", "mypy"]
+
+[project.urls]
+Homepage = "https://rumik.ai/"
+Source = "https://github.com/rumik-ai/livekit-plugins-rumik-ai"
+Issues = "https://github.com/rumik-ai/livekit-plugins-rumik-ai/issues"
+Documentation = "https://docs.livekit.io/agents/integrations/tts/"
+
+[tool.hatch.version]
+path = "livekit/plugins/rumik_ai/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["livekit"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/livekit", "/README.md", "/LICENSE"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+# Match the livekit-agents monorepo config so this plugin type-checks identically.
+disallow_any_generics = false
+plugins = ["pydantic.mypy"]