avartha-python-sdk 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

avartha_python_sdk-0.0.4.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: avartha-python-sdk
+Version: 0.0.4
+Summary: Python clients for Avartha Realtime text, streaming speech, and platform management
+Author-email: "Avartha Inc." <team@avartha.ai>
+License-Expression: LicenseRef-Avartha-Proprietary
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES
+Requires-Dist: httpx<0.29,>=0.28.1
+Requires-Dist: websockets<16,>=15.0.1
+Requires-Dist: pydantic<3,>=2.11
+Requires-Dist: typing-extensions<5,>=4.12
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: pytest-asyncio<2,>=1; extra == "dev"
+Requires-Dist: ruff<0.17,>=0.16; extra == "dev"
+Requires-Dist: mypy<3,>=2.3; extra == "dev"
+Requires-Dist: build<2,>=1; extra == "dev"
+Requires-Dist: setuptools-scm<9,>=8; extra == "dev"
+Dynamic: license-file
+
+# Avartha Python SDK
+
+Synchronous and asynchronous Python clients for Avartha Realtime text,
+streaming speech, and platform management. Requires Python 3.12+.
+
+## Install
+
+```sh
+python -m pip install avartha-python-sdk
+```
+
+Configure your Avartha API key and platform root:
+
+```sh
+export AVARTHA_API_KEY='avk_...'
+export AVARTHA_BASE_URL='https://platform.preview.avartha.ai'
+```
+
+Clients default to the preview platform and the `serverless` tier. Set
+`AVARTHA_BASE_URL` for another environment or `tier="dedicated"` for dedicated
+inference. Use model and voice IDs available to your workspace and tier.
+
+## Discover models
+
+```python
+from avartha import OpenAI
+
+with OpenAI() as client:
+    for model in client.models.list():
+        print(model.id, model.to_dict().get("protocols", []))
+```
+
+Choose a model supporting `openai_realtime` for text, `elevenlabs_tts` for
+speech synthesis, or `elevenlabs_asr` for speech recognition.
+
+## Generate text
+
+Replace `your-avartha-model` with a Realtime text model returned by discovery:
+
+```python
+from avartha import OpenAI
+
+with OpenAI() as client:
+    with client.realtime.connect(model="your-avartha-model") as connection:
+        connection.session.update(session={"type": "realtime", "output_modalities": ["text"]})
+        connection.conversation.item.create(
+            item={
+                "type": "message",
+                "role": "user",
+                "content": [{"type": "input_text", "text": "Explain Python dictionaries."}],
+            }
+        )
+        connection.response.create()
+        for event in connection:
+            if event.type == "response.output_text.delta":
+                print(event.delta, end="", flush=True)
+            elif event.type == "response.done":
+                if event.response.status != "completed":
+                    raise RuntimeError(f"Response ended with status: {event.response.status}")
+                break
+            elif event.type == "error":
+                raise RuntimeError(event.error.message)
+```
+
+For asynchronous text generation, use `AsyncOpenAI`, `async with`, `await`,
+and `async for`. Close clients and active WebSocket sessions when finished.
+Inference consumes credits.
+
+## Supported workflows
+
+| Workflow | Client and interface |
+| --- | --- |
+| Realtime text | `OpenAI` / `AsyncOpenAI`: `realtime.connect` |
+| Model discovery | `OpenAI` / `AsyncOpenAI`: `models.list`, `models.retrieve` |
+| Streaming TTS | `ElevenLabs` / `AsyncElevenLabs`: `text_to_speech.convert_realtime` |
+| Multi-context TTS | `ElevenLabs` / `AsyncElevenLabs`: `text_to_speech.connect_multi_context` |
+| Realtime ASR | `await client.speech_to_text.realtime.connect(...)` on either speech client |
+| Speech discovery | Speech clients: models, voices, voice settings, ASR languages |
+| Workspaces, members, invitations, endpoints | `Control` / `AsyncControl` |
+| Combined inference and management | `Avartha` / `AsyncAvartha` |
+
+Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,
+and file transcription are unavailable. Agent management and conversation
+sessions are planned; accessing `conversational_ai` currently raises
+`NotImplementedError`.
+
+## Migrating and handling errors
+
+Import clients, types, and exceptions from `avartha`. Neither the OpenAI nor
+ElevenLabs SDK needs to be installed. The supported interfaces are compatible
+with OpenAI Python 3.13.0 and ElevenLabs Python 2.68.0. Model and voice IDs are
+specific to the selected Avartha environment.
+
+OpenAI-compatible HTTP discovery uses `avartha.APIStatusError` and
+`avartha.APIConnectionError`. Speech HTTP errors use `avartha.ApiError`.
+Management HTTP status errors use `avartha.PlatformAPIError`. Speech and
+management HTTP network failures also raise `avartha.ApiError`, with no status
+or headers and the original exception in `__cause__`.
+
+Handle Realtime server error events in the receive loop. HTTP timeout and
+retry settings do not configure WebSocket connections. Management writes are
+never retried automatically.
+
+## Complete guides and examples
+
+The [source archive on PyPI](https://pypi.org/project/avartha-python-sdk/#files)
+includes `README.md`, customer guides in `docs/`, and runnable examples in
+`examples/`. Download and unpack the archive to read the migration, compatibility,
+and platform-management guides and run the text, speech, and endpoint examples.

{avartha_python_sdk-0.0.3.dist-info → avartha_python_sdk-0.0.4.dist-info}/RECORD

@@ -15,7 +15,6 @@ avartha/_speech_config.py,sha256=jL0M8Z6MGXzfgf3Lm7QMMEKDtVXCW5-jrqz5WEtu9g4,178
 avartha/_speech_http.py,sha256=LNcHPLleuLDQNfMIlUD-ijua5h4VPhqXAmcDrXB8Cdg,10632
 avartha/_speech_resources.py,sha256=61DKhTnz_bpOTjY_CpeR0mXs9ui9-XeaYgpSDNk_NpE,16954
 avartha/_unsupported.py,sha256=qrbsxi2SL6co5M2uLs4fTVOoISuUm58khoayeL22gPE,637
-avartha/_version.py,sha256=_imd66x09sTd41VCdBD0RFplr2e75yP5Ped99So9xP0,520
 avartha/_websocket.py,sha256=9R05huh1n8spuyg1n_aIJN0Uk_kLG7BbNPD88wogIKY,855
 avartha/_ws_state.py,sha256=Im2W-UJtCBimYU5vlYBbVRL06DGwuw0Q5ufy4sSGIeM,5049
 avartha/client.py,sha256=jm4CYnzORxtWn2LiVIfBff53dNsUiJjuFb6V01lxBTQ,5006
@@ -249,9 +248,9 @@ avartha/types/speech/voice_sharing_response.py,sha256=KRO9Rq80wTYV5of2bRrFTVJSDf
 avartha/types/speech/voice_sharing_response_category.py,sha256=0yFm6b7R4piHdNTdBWTQYKpNPxW8r2HJvnMdVpT7s5U,241
 avartha/types/speech/voice_sharing_state.py,sha256=8EBRbrRaDhUEap39kDXmt54AYeG172fnuBmRV1TSHP4,201
 avartha/types/speech/voice_verification_response.py,sha256=IL_Z1OTIiR9mvuaWzF9-GsL7pMRZ5fJeV_W3FfjLTTY,770
-avartha_python_sdk-0.0.3.dist-info/licenses/LICENSE,sha256=1ulXrK7aq7kBXX1scK6IiOgnbwqpmK6kWIB3CYznVG8,1135
-avartha_python_sdk-0.0.3.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=t5pUaCILEOze2IsP3TD9I382AtW4njjqZTg9yOfUKbc,13211
-avartha_python_sdk-0.0.3.dist-info/METADATA,sha256=BdfP9tDdpnUBoGoiw3EudFW_lwJs_xeur5ExB4G0f68,17211
-avartha_python_sdk-0.0.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-avartha_python_sdk-0.0.3.dist-info/top_level.txt,sha256=cj2kDXl33tO2IPWPduSTukcwozPnYKOsVUVE9QZRUr0,8
-avartha_python_sdk-0.0.3.dist-info/RECORD,,
+avartha_python_sdk-0.0.4.dist-info/licenses/LICENSE,sha256=1ulXrK7aq7kBXX1scK6IiOgnbwqpmK6kWIB3CYznVG8,1135
+avartha_python_sdk-0.0.4.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=R62M0553miTc6E42IVFLUIYkLFim_mf_Abq1lty0IaQ,13081
+avartha_python_sdk-0.0.4.dist-info/METADATA,sha256=czBiWHsr1vStz2ovwxvukAfTPzYZDqDdmdstwZvGm_g,5579
+avartha_python_sdk-0.0.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+avartha_python_sdk-0.0.4.dist-info/top_level.txt,sha256=cj2kDXl33tO2IPWPduSTukcwozPnYKOsVUVE9QZRUr0,8
+avartha_python_sdk-0.0.4.dist-info/RECORD,,

{avartha_python_sdk-0.0.3.dist-info → avartha_python_sdk-0.0.4.dist-info}/licenses/THIRD_PARTY_NOTICES

@@ -1,15 +1,15 @@
 Third-party schema notices
 ==========================
 
-The WebSocket data declarations under src/avartha/types/realtime, responses,
-shared, shared_params, model.py, and websocket_connection_options.py are derived from
-OpenAI Python 3.13.0. Model discovery contracts are captured in
-tests/fixtures/openai-models-3.13.0.json. Declarations under
-src/avartha/types/speech are derived from ElevenLabs Python 2.68.0.
-Avartha removed descriptions and legacy Pydantic branches and replaced runtime
-imports. Speech contract source hashes are in tests/fixtures/elevenlabs-2.68.0.json
-and tests/fixtures/speech-http-2.68.0.json. These notices
-apply to those declarations; the Avartha proprietary LICENSE remains unchanged.
+The declarations in avartha.types.realtime, avartha.types.responses,
+avartha.types.shared, avartha.types.shared_params, avartha.types.model, and
+avartha.types.websocket_connection_options are derived from OpenAI Python
+3.13.0. The declarations in avartha.types.speech are derived from ElevenLabs
+Python 2.68.0.
+
+Avartha modified these declarations by removing descriptions and legacy
+Pydantic branches and replacing runtime imports. These notices apply to those
+declarations; the Avartha proprietary LICENSE remains unchanged.
 
 OpenAI Python 3.13.0
 --------------------

avartha/_version.py

@@ -1,24 +0,0 @@
-# file generated by vcs-versioning
-# don't change, don't track in version control
-from __future__ import annotations
-
-__all__ = [
-    "__version__",
-    "__version_tuple__",
-    "version",
-    "version_tuple",
-    "__commit_id__",
-    "commit_id",
-]
-
-version: str
-__version__: str
-__version_tuple__: tuple[int | str, ...]
-version_tuple: tuple[int | str, ...]
-commit_id: str | None
-__commit_id__: str | None
-
-__version__ = version = '0.0.3'
-__version_tuple__ = version_tuple = (0, 0, 3)
-
-__commit_id__ = commit_id = None

avartha_python_sdk-0.0.3.dist-info/METADATA

@@ -1,441 +0,0 @@
-Metadata-Version: 2.4
-Name: avartha-python-sdk
-Version: 0.0.3
-Summary: Python clients for Avartha inference, voice agents, and platform management
-Author-email: "Avartha Inc." <team@avartha.ai>
-License-Expression: LicenseRef-Avartha-Proprietary
-Project-URL: Repository, https://github.com/avartha/avartha-python-sdk
-Project-URL: Issues, https://github.com/avartha/avartha-python-sdk/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Typing :: Typed
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-License-File: LICENSE
-License-File: THIRD_PARTY_NOTICES
-Requires-Dist: httpx<0.29,>=0.28.1
-Requires-Dist: websockets<16,>=15.0.1
-Requires-Dist: pydantic<3,>=2.11
-Requires-Dist: typing-extensions<5,>=4.12
-Provides-Extra: dev
-Requires-Dist: pytest<10,>=8; extra == "dev"
-Requires-Dist: pytest-asyncio<2,>=1; extra == "dev"
-Requires-Dist: ruff<0.17,>=0.16; extra == "dev"
-Requires-Dist: mypy<3,>=2.3; extra == "dev"
-Requires-Dist: build<2,>=1; extra == "dev"
-Requires-Dist: setuptools-scm<9,>=8; extra == "dev"
-Dynamic: license-file
-
-# Avartha Python SDK
-
-[![PyPI version](https://img.shields.io/pypi/v/avartha-python-sdk)](https://pypi.org/project/avartha-python-sdk/)
-
-Synchronous and asynchronous Python clients for Avartha Realtime LLMs,
-streaming speech, and platform management. Requires Python 3.12+.
-
-**Familiar Python interfaces for OpenAI Realtime and ElevenLabs speech.** Change
-client, type, and exception imports, then configure Avartha credentials, URLs,
-and model/voice IDs. The supported APIs use the same method names and event loops:
-
-```diff
--from openai import OpenAI, AsyncOpenAI
-+from avartha import OpenAI, AsyncOpenAI
-```
-
-```diff
--from elevenlabs.client import ElevenLabs, AsyncElevenLabs
-+from avartha import ElevenLabs, AsyncElevenLabs
-```
-
-Neither vendor SDK needs to be installed. Avartha supports Realtime text,
-streaming speech, HTTP discovery, and platform management. Managed inference is
-**WebSocket-only**; Chat Completions, Responses, and HTTP speech inference are
-unavailable. See the guides below for supported features and migration steps.
-
-## Documentation
-
-- [Migrating from OpenAI and ElevenLabs](docs/migration.md)
-- [Compatibility and endpoint coverage](docs/compatibility.md)
-- [Platform management](docs/platform.md)
-- [Runnable examples](examples)
-- [Contributing](CONTRIBUTING.md)
-
-## Installation
-
-Install from [PyPI](https://pypi.org/project/avartha-python-sdk/):
-
-```sh
-python -m pip install avartha-python-sdk
-```
-
-Set your Avartha API key and platform root. Update `AVARTHA_BASE_URL` to match
-your environment:
-
-```sh
-export AVARTHA_API_KEY='avk_...'
-export AVARTHA_BASE_URL='https://platform.preview.avartha.ai'
-```
-
-Clients default to `https://platform.preview.avartha.ai` and the `serverless`
-inference tier. Set `AVARTHA_BASE_URL` to use another platform root. Both protocol
-clients derive their service URLs from this root. Use model and voice IDs from
-the selected environment; vendor IDs are not mapped automatically.
-
-## Usage
-
-Use the OpenAI Realtime interface for LLM inference. The client reads
-`AVARTHA_API_KEY` from the environment; `api_key` can also be passed explicitly.
-
-```python
-from avartha import OpenAI
-
-with OpenAI() as client:
-    with client.realtime.connect(model="google/gemma-4-26b-a4b-it") as connection:
-        connection.session.update(session={"type": "realtime", "output_modalities": ["text"]})
-        connection.conversation.item.create(
-            item={
-                "type": "message",
-                "role": "user",
-                "content": [{"type": "input_text", "text": "Explain Python dictionaries."}],
-            }
-        )
-        connection.response.create()
-        for event in connection:
-            if event.type == "response.output_text.delta":
-                print(event.delta, end="", flush=True)
-            elif event.type == "response.done":
-                if event.response.status != "completed":
-                    raise RuntimeError(f"Response ended with status: {event.response.status}")
-                break
-            elif event.type == "error":
-                raise RuntimeError(event.error.message)
-```
-
-Keep the connection open for additional turns. Create another conversation item
-and response on the same connection to preserve conversation state.
-
-To discover available models and their enabled protocols:
-
-```python
-from avartha import OpenAI
-
-with OpenAI() as client:
-    for model in client.models.list():
-        print(model.id, model.to_dict().get("protocols", []))
-```
-
-Model availability depends on your workspace, environment, and tier. Replace
-the example IDs with models returned for your key and the protocol you need:
-`openai_realtime`, `elevenlabs_tts`, or `elevenlabs_asr`.
-
-## Async usage
-
-Use `AsyncOpenAI`, await operations, and iterate with `async for`. The sync and
-async clients accept the same request parameters and return the same event types.
-
-```python
-import asyncio
-from avartha import AsyncOpenAI
-
-
-async def main():
-    async with AsyncOpenAI() as client:
-        async with client.realtime.connect(model="google/gemma-4-26b-a4b-it") as connection:
-            await connection.session.update(
-                session={"type": "realtime", "output_modalities": ["text"]}
-            )
-            await connection.conversation.item.create(
-                item={
-                    "type": "message",
-                    "role": "user",
-                    "content": [{"type": "input_text", "text": "Explain Python dictionaries."}],
-                }
-            )
-            await connection.response.create()
-            async for event in connection:
-                if event.type == "response.output_text.delta":
-                    print(event.delta, end="", flush=True)
-                elif event.type == "response.done":
-                    if event.response.status != "completed":
-                        raise RuntimeError(f"Response ended with status: {event.response.status}")
-                    break
-                elif event.type == "error":
-                    raise RuntimeError(event.error.message)
-
-
-asyncio.run(main())
-```
-
-[Complete Realtime example](examples/realtime.py).
-
-## Streaming speech
-
-`ElevenLabs()` defaults to the same Avartha platform root and serverless tier.
-It provides ElevenLabs-compatible realtime speech and discovery APIs.
-
-### Text to speech
-
-Discover voices for the selected TTS model using `request_options`:
-
-```python
-from avartha import ElevenLabs
-
-with ElevenLabs() as client:
-    voices = client.voices.get_all(
-        request_options={
-            "additional_query_parameters": {"model_id": "qwen/qwen3-tts-12hz-1.7b-base"}
-        }
-    )
-    for voice in voices.voices:
-        print(voice.voice_id)
-```
-
-Stream text over a WebSocket with `convert_realtime`. Avartha returns PCM;
-select a sample rate supported by your model and write a WAV header for playback.
-This example uses Qwen's 24 kHz output:
-
-```python
-import wave
-from avartha import ElevenLabs
-
-with ElevenLabs() as client:
-    audio = client.text_to_speech.convert_realtime(
-        voice_id="carol",
-        model_id="qwen/qwen3-tts-12hz-1.7b-base",
-        output_format="pcm_24000",
-        text=iter(["Welcome. ", "How can I help?"]),
-    )
-    with wave.open("welcome.wav", "wb") as output:
-        output.setnchannels(1)
-        output.setsampwidth(2)
-        output.setframerate(24000)
-        for chunk in audio:
-            output.writeframes(chunk)
-```
-
-The default output format is `pcm_24000`. Use `AsyncElevenLabs` and `async for`
-for async TTS; the async client's `text` accepts either a regular iterable or
-an async iterable. Run the
-[TTS example](examples/tts.py) with `--async` to use that client.
-
-Text fragments are forwarded as supplied, without waiting for word or sentence
-boundaries or adding spaces. Include any intended whitespace in your text.
-The Avartha Platform handles buffering and segmentation. Available audio continues
-to arrive while the text producer is paused; when synthesis starts depends on the model.
-
-The SDK's single-context and multi-context TTS helpers always use
-`auto_mode=true`. `auto_mode=False` and `default_mode` are not supported.
-
-For multiple utterances on one connection, use `connect_multi_context` on
-either client. A background consumer can iterate over the session before contexts
-are created and between turns; messages are keyed by `message.context_id`.
-For a finite batch, create and flush contexts, then iterate over `session.drain()`.
-Session iteration waits until the connection closes via `close_socket()` or when
-its `with` or `async with` block exits. See the [multi-context example](examples/tts_multi_context.py)
-and [TTS lifecycle details](docs/compatibility.md#realtime-tts).
-
-HTTP `text_to_speech.stream` and `.convert` are not provided by this SDK;
-managed inference uses the realtime methods above.
-
-### Speech to text
-
-Realtime ASR uses `await client.speech_to_text.realtime.connect(...)` on both
-ElevenLabs client variants. Send mono PCM16 audio and await a committed transcript.
-[The complete example](examples/realtime_asr.py) reads a WAV file, registers
-transcript/error callbacks, streams chunks, commits, and closes the connection:
-
-```sh
-python examples/realtime_asr.py mistralai/voxtral-mini-4b-realtime-2602 speech-16k.wav
-```
-
-`previous_text` is optional text context for transcription. When omitted from
-`connection.send` data, Avartha sends `null`, meaning no context. You can omit
-this field when streaming audio without prior text.
-
-File-based HTTP `speech_to_text.convert` is retired on managed inference.
-
-## Agents
-
-Agent management, tools, knowledge bases, and conversation sessions/history are
-currently unavailable. Accessing `client.conversational_ai` raises
-`NotImplementedError`.
-
-ElevenLabs-compatible `conversational_ai` support is planned for an upcoming
-release, including agent creation, tools, knowledge-base documents, and
-conversations.
-
-The following example previews the planned API. It requires that future SDK
-release and a service implementing the corresponding agent endpoints:
-
-```python
-from avartha import ElevenLabs
-
-with ElevenLabs(base_url="https://your-compatible-agent-service") as client:
-    agent = client.conversational_ai.agents.create(
-        name="Support",
-        conversation_config={
-            "agent": {
-                "first_message": "What can I help you with?",
-                "prompt": {"prompt": "Help customers find concise, accurate answers."},
-            },
-            "tts": {"voice_id": "your-voice"},
-        },
-    )
-    print(agent.agent_id)
-```
-
-The planned `avartha.conversational_ai` namespace will also include
-`Conversation`, `AsyncConversation`, and `ClientTools`.
-
-## Using types
-
-Import types and exceptions from Avartha. The SDK provides its own classes for
-the supported APIs, preserving upstream fields and serialization methods.
-Neither `openai` nor `elevenlabs` needs to be installed:
-
-```python
-from avartha import OpenAI
-from avartha.types import Model
-
-with OpenAI() as client:
-    models: list[Model] = client.models.list().data
-    print([model.to_dict() for model in models])
-```
-
-Use `avartha.types.realtime` for OpenAI-compatible Realtime events and
-`avartha.types.speech` for ElevenLabs-compatible speech types. These namespaces
-cover the APIs supported by Avartha. Platform management responses are JSON
-dictionaries and lists.
-
-ElevenLabs-compatible transcription options are also available from the root:
-
-```python
-from avartha import AudioFormat, CommitStrategy, RealtimeAudioOptions
-
-options = RealtimeAudioOptions(
-    model_id="your-avartha-asr-model",
-    audio_format=AudioFormat.PCM_16000,
-    sample_rate=16000,
-    commit_strategy=CommitStrategy.VAD,
-)
-```
-
-## Handling errors
-
-Import exception classes from Avartha too; upstream exception classes will not
-catch Avartha's exceptions. For HTTP discovery:
-
-```python
-from avartha import APIConnectionError, APIStatusError, OpenAI
-
-with OpenAI() as client:
-    try:
-        client.models.list()
-    except APIConnectionError as error:
-        print("Connection failed:", error)
-    except APIStatusError as error:
-        print("Request failed:", error.status_code, error.request_id)
-```
-
-Realtime server errors are events, so handle `event.type == "error"` in the
-receive loop. Inspect `response.done.response.status` for completion, failure,
-or cancellation; a terminal event alone does not prove successful inference.
-Connection failures can raise WebSocket exceptions.
-
-ElevenLabs-compatible HTTP/TTS helper errors, including speech HTTP network
-failures and timeouts, use `avartha.ApiError`.
-ASR also emits `RealtimeEvents.ERROR`.
-
-Management failures use `avartha.PlatformAPIError`, retaining the HTTP status,
-response body, field errors, request ID, and `Retry-After` header. Management
-network failures and timeouts use `avartha.ApiError`.
-
-For speech and management HTTP request failures without a server response,
-`ApiError.status_code` and `ApiError.headers` are `None`, and `ApiError.body`
-describes the failure. The original exception is available as `error.__cause__`.
-
-## Retries and timeouts
-
-Set timeouts and retries for OpenAI-compatible HTTP discovery on the client:
-
-```python
-from avartha import OpenAI
-
-with OpenAI(timeout=30.0, max_retries=0) as client:
-    print(client.models.list())
-```
-
-HTTP and WebSocket retry settings are separate. The OpenAI-compatible clients accept
-`client.realtime.connect(..., max_retries=0)` to disable automatic reconnection,
-and `websocket_connection_options` for transport settings. Use `asyncio.timeout`
-when an async operation needs an overall deadline. Close active sessions when
-cancelling. ElevenLabs `timeout` configures HTTP calls; it does not set a
-WebSocket receive deadline. Platform management writes are never retried
-automatically. See [timeouts and cleanup](docs/migration.md#timeouts-retries-and-closing-clients).
-
-## Configuration
-
-| Client | Meaning of explicit `base_url` |
-| --- | --- |
-| `OpenAI`, `AsyncOpenAI` | Full inference base: `https://platform.preview.avartha.ai/inference/serverless/openai/v1` |
-| `ElevenLabs`, `AsyncElevenLabs` | Speech service root before `/v1`: `https://platform.preview.avartha.ai/inference/serverless/elevenlabs` |
-| `Avartha`, `AsyncAvartha`, `Control`, `AsyncControl` | Platform root: `https://platform.preview.avartha.ai` |
-
-Without an explicit URL, protocol clients derive their URL from
-`AVARTHA_BASE_URL`, defaulting to `https://platform.preview.avartha.ai` and the
-`serverless` tier. Set `tier="dedicated"` for dedicated inference; there is no
-automatic fallback between tiers. An explicit protocol `base_url` takes
-precedence over `tier`. `AVARTHA_ELEVENLABS_BASE_URL` overrides the derived speech
-root, and an explicit ElevenLabs `base_url` overrides that environment variable.
-
-Keys are read at construction from `AVARTHA_API_KEY` or `api_key`.
-Vendor default keys and base URL variables are not substituted.
-[Migration configuration](docs/migration.md#configuration).
-
-Always close clients or use context managers. OpenAI manages and closes its HTTP
-client; custom `http_client` arguments are unsupported. ElevenLabs and Control
-close only HTTP clients they created. Close active WebSocket sessions separately.
-
-## Platform management
-
-Use the combined `Avartha` client for inference plus management:
-
-```python
-from avartha import Avartha
-
-with Avartha() as client:
-    print(client.control.catalog.models())
-    print(client.control.catalog.skus(provider="modal"))
-    print(client.control.organizations.list())
-    print(client.control.organizations.limits("your-workspace-id"))
-    print(client.control.endpoints.list(workspace_id="your-workspace-id"))
-```
-
-`client.openai` and `client.elevenlabs` are the protocol clients;
-`client.realtime` and `client.models` are shortcuts to the corresponding OpenAI
-resources, including model listing and retrieval. `AsyncAvartha`, `Control`,
-and `AsyncControl` are available too. Workspace administration includes
-organization creation, renaming, deletion, leaving, member roles, and invitation
-creation, revocation, and acceptance. For example,
-`client.control.organizations.members.list("your-workspace-id")` lists members.
-See [workspace administration](docs/platform.md#workspace-administration) for
-sync/async usage and server permissions.
-
-Endpoint creation, readiness waiting,
-scaling, routing, stopping, and deletion are described in the
-[management guide](docs/platform.md).
-
-## Examples
-
-Runnable examples cover [Realtime text](examples/realtime.py),
-[TTS](examples/tts.py), [multi-context TTS](examples/tts_multi_context.py),
-[ASR](examples/realtime_asr.py), and [endpoint management](examples/endpoints.py).
-Microphone capture and speaker playback are handled by your application.
-
-Running inference examples consumes credits. For SDK development and checks,
-see [Contributing](CONTRIBUTING.md).