avartha-python-sdk 0.0.4__tar.gz → 0.0.5__tar.gz

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/MANIFEST.in

@@ -6,4 +6,4 @@ exclude src/avartha/_version.py
 recursive-include src/avartha_python_sdk.egg-info PKG-INFO SOURCES.txt dependency_links.txt requires.txt top_level.txt
 include docs/pypi.md docs/compatibility.md docs/migration.md docs/platform.md
 include examples/realtime.py examples/tts.py examples/tts_multi_context.py
-include examples/realtime_asr.py examples/endpoints.py
+include examples/realtime_asr.py

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avartha-python-sdk
-Version: 0.0.4
+Version: 0.0.5
 Summary: Python clients for Avartha Realtime text, streaming speech, and platform management
 Author-email: "Avartha Inc." <team@avartha.ai>
 License-Expression: LicenseRef-Avartha-Proprietary
@@ -47,9 +47,10 @@ 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.
+Clients default to the preview platform and support only serverless inference.
+Set `AVARTHA_BASE_URL` for another environment. Use model and voice IDs available
+to your workspace. Unsupported tier values and dedicated inference URLs raise
+`ConfigurationError` locally before any request.
 
 ## Discover models
 
@@ -107,7 +108,7 @@ Inference consumes credits.
 | 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` |
+| Workspaces, members, invitations | `Control` / `AsyncControl` |
 | Combined inference and management | `Avartha` / `AsyncAvartha` |
 
 Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/README.md

@@ -95,7 +95,7 @@ with OpenAI() as client:
         print(model.id, model.to_dict().get("protocols", []))
 ```
 
-Model availability depends on your workspace, environment, and tier. Replace
+Model availability depends on your workspace and environment. Replace
 the example IDs with models returned for your key and the protocol you need:
 `openai_realtime`, `elevenlabs_tts`, or `elevenlabs_asr`.
 
@@ -210,8 +210,18 @@ 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.
+Live speech-to-text (realtime ASR) is asynchronous on both `ElevenLabs` and
+`AsyncElevenLabs`. This also applies through `Avartha` and `AsyncAvartha` at
+`client.elevenlabs.speech_to_text.realtime`; the synchronous `Avartha` client
+does not provide a blocking live STT interface.
+
+Await `realtime.connect()`, `connection.send()`, `connection.commit()`, and
+`connection.close()`. Register callbacks with `connection.on()` without `await`.
+Use `AsyncAvartha` or `AsyncElevenLabs` for an async application. See the
+[live STT execution guidance](docs/migration.md#live-speech-to-text) for scripts
+and applications with an existing event loop.
+
+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:
 
@@ -354,10 +364,12 @@ automatically. See [timeouts and cleanup](docs/migration.md#timeouts-retries-and
 
 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.
+`serverless` tier. Only serverless inference is supported. Unsupported `tier`
+values and dedicated inference URLs raise `ConfigurationError` locally before
+any request; the SDK does not silently change the selected tier.
+`AVARTHA_ELEVENLABS_BASE_URL` overrides the derived speech root, and an explicit
+protocol `base_url` overrides its derived URL. URL overrides do not bypass tier
+validation.
 
 Keys are read at construction from `AVARTHA_API_KEY` or `api_key`.
 Vendor default keys and base URL variables are not substituted.
@@ -379,7 +391,6 @@ with Avartha() as client:
     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;
@@ -392,15 +403,11 @@ creation, revocation, and acceptance. For example,
 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).
+[ASR](examples/realtime_asr.py).
 Microphone capture and speaker playback are handled by your application.
 
 Running inference examples consumes credits.

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/docs/compatibility.md

@@ -8,14 +8,14 @@ Avartha; see the [migration guide](migration.md).
 ## Supported APIs
 
 SDK support and server availability are separate. Select a model available to
-your workspace and tier, and use only the features that model supports.
+your workspace on serverless inference, and use only the features that model supports.
 Avartha managed inference uses WebSockets. Discovery and platform management
 use HTTP.
 
 | Surface | SDK support | Server prerequisites |
 | --- | --- | --- |
 | OpenAI Realtime text | Sync/async `realtime.connect()` | A model supporting `openai_realtime` and the requested session options |
-| OpenAI model discovery | Sync/async `models.list()` and `models.retrieve(model)` | A valid Avartha key; results depend on workspace and tier |
+| OpenAI model discovery | Sync/async `models.list()` and `models.retrieve(model)` | A valid Avartha key; results depend on workspace |
 | OpenAI Realtime audio, transcription, images, and beta API | Unavailable | Use speech clients for supported audio workflows |
 | Chat Completions, Responses, SSE, and OpenAI HTTP speech | Unavailable | Managed inference requires a Realtime connection |
 | Speech models and voices | Typed sync/async HTTP discovery | A visible speech model; voice discovery requires a routable TTS model |
@@ -25,11 +25,11 @@ use HTTP.
 | Realtime ASR | Async connections on both speech clients | An ASR model supporting the supplied audio format and sample rate |
 | HTTP TTS and file transcription | Unavailable | Use realtime speech methods |
 | Agents, tools, knowledge bases, conversation sessions/history | Planned; currently unavailable | Accessing `conversational_ai` raises `NotImplementedError` |
-| Catalog, workspaces, members, invitations, and endpoints | Sync/async `Control` | An Avartha API key with the required workspace role and allocation |
+| Catalog, workspaces, members, and invitations | Sync/async `Control` | An Avartha API key with the required workspace role and allocation |
 | API-key administration | Unavailable through `Control` | Use the platform portal; these operations require a browser session |
 
 See [platform management](platform.md) for workspace roles, invitation
-requirements, endpoint readiness, and provisioning.
+requirements, and permissions.
 
 ## OpenAI Realtime text
 
@@ -56,8 +56,8 @@ schema compatibility. Unsupported HTTP resources, including Chat Completions,
 Responses, and Realtime calls/client secrets, raise the same exception.
 The older `client.beta.realtime` wire schema is outside this contract.
 
-The constructor and `copy()` / `with_options()` accept an Avartha `tier` option;
-custom `http_client` arguments are unsupported.
+The constructor accepts only `tier="serverless"`. Client copies apply the same
+configuration validation. Custom `http_client` arguments are unsupported.
 HTTP settings such as `timeout` and `max_retries` do not control the WebSocket. Use
 `websocket_connection_options` and the arguments to `realtime.connect()` for
 socket timeouts and retries. Closing a client closes its internally created HTTP
@@ -81,12 +81,12 @@ with OpenAI() as client:
 ```
 
 The client uses these HTTP routes under
-`/inference/{serverless|dedicated}/openai/v1`:
+`/inference/serverless/openai/v1`:
 
 | SDK method | GET path | Server prerequisites |
 | --- | --- | --- |
-| `models.list()` | `/models` | Returns models visible to the caller on the selected tier; an empty list is valid |
-| `models.retrieve(model)` | `/models/{model}` | Model ID must be visible on that tier; slashes in IDs are URL-encoded |
+| `models.list()` | `/models` | Returns serverless models visible to the caller; an empty list is valid |
+| `models.retrieve(model)` | `/models/{model}` | Model ID must be visible on serverless inference; slashes in IDs are URL-encoded |
 
 Both clients return typed `avartha.types.Model` objects and preserve additional
 platform fields such as `protocols`, `model_type`, and `websocket_limits`.
@@ -115,11 +115,11 @@ raise `APITimeoutError`. The OpenAI HTTP 422 class is
 ## Speech HTTP discovery
 
 Speech discovery uses these HTTP routes under
-`/inference/{serverless|dedicated}/elevenlabs`:
+`/inference/serverless/elevenlabs`:
 
 | SDK method | GET path | Server prerequisites |
 | --- | --- | --- |
-| `models.list()` | `/v1/models` | A speech model visible to the caller and tier |
+| `models.list()` | `/v1/models` | A serverless speech model visible to the caller |
 | `voices.get_all()` | `/v1/voices` | A routable TTS model with runtime voice discovery |
 | `voices.search(...)` | `/v2/voices` | Same; supported filters are `search`, `page_size` (1–100), `next_page_token`, and `include_total_count` |
 | `voices.get(voice_id)` | `/v1/voices/{voice_id}` | Voice exists for the selected model |
@@ -261,12 +261,14 @@ option in the SDK does not make it available on the server. Runnable examples:
 ## URLs and authentication
 
 - `Avartha` and `Control` accept a platform root, including a proxy prefix.
-- OpenAI defaults to `ROOT/inference/{tier}/openai/v1`, using bearer auth.
-- ElevenLabs defaults to `ROOT/inference/{tier}/elevenlabs` and appends its
+- OpenAI defaults to `ROOT/inference/serverless/openai/v1`, using bearer auth.
+- ElevenLabs defaults to `ROOT/inference/serverless/elevenlabs` and appends its
   original `/v1/...` paths, using `xi-api-key`.
 - An explicit protocol `base_url` is a full dialect/service base. Speech also
   supports `AVARTHA_ELEVENLABS_BASE_URL` as an override.
-- Both protocol clients default to `serverless`; `tier="dedicated"` never falls back.
+- Both protocol clients support only `tier="serverless"`. Other tier values and
+  dedicated inference URLs raise `ConfigurationError` before any request,
+  including with explicit or environment URL overrides.
 - HTTP/HTTPS maps to WS/WSS. No implicit hosted-vendor credential fallback exists.
 - Clients never read vendor environment variables. `OPENAI_ADMIN_KEY`,
   `OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_CUSTOM_HEADERS`, `OPENAI_ORG_ID`,

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/docs/migration.md

@@ -174,7 +174,7 @@ your application uses it.
 ### Discover models, voices, and ASR languages
 
 Call discovery resources on the speech client. Replace the example model IDs
-with models available for your workspace, environment, and tier:
+with models available for your workspace and environment:
 
 ```python
 from avartha import ElevenLabs
@@ -229,6 +229,25 @@ Text fragments are forwarded unchanged, including whitespace. Include any
 intended spaces in your text. The Avartha Platform handles buffering and
 segmentation; when synthesis starts depends on the model.
 
+TTS `convert_realtime` supports sync and async clients; the async helper also
+accepts async text streams. Both receive audio independently of text production.
+See [input cancellation and cleanup](compatibility.md#realtime-tts)
+for blocking text iterators and early playback stops.
+
+### Live speech-to-text
+
+Realtime ASR is asynchronous on both speech clients and through
+`Avartha.elevenlabs.speech_to_text.realtime` and
+`AsyncAvartha.elevenlabs.speech_to_text.realtime`. Choosing `Avartha` does not
+make live STT operations synchronous; existing awaited calls remain supported.
+
+Await `realtime.connect()`, `connection.send()`, `connection.commit()`, and
+`connection.close()`. Callback registration with `connection.on()` is synchronous.
+Callbacks run on the session's event loop, which must remain running to receive
+transcripts. Handlers can be ordinary functions or async functions.
+ASR events retain their names and raw dictionary payloads, including the
+deprecated `UNACCEPTED_TERMS_ERROR` callback alias.
+
 `previous_text` supplies optional text context for transcription. When omitted,
 Avartha sends `null`, meaning no context. Audio-send code can omit the field:
 
@@ -237,14 +256,18 @@ async def send_audio(connection, encoded_chunk):
     await connection.send({"audio_base_64": encoded_chunk})
 ```
 
-See the [complete ASR example](../examples/realtime_asr.py).
+The [complete ASR example](../examples/realtime_asr.py) uses `AsyncElevenLabs`,
+waits for a committed transcript, and awaits `connection.close()` in `finally`.
+For a combined inference and management client, adapt that example to use
+`async with AsyncAvartha() as client` and connect through
+`await client.elevenlabs.speech_to_text.realtime.connect(options)`.
 
-TTS `convert_realtime` supports sync and async clients; the async helper also
-accepts async text streams. Both receive audio independently of text production.
-See [input cancellation and cleanup](compatibility.md#realtime-tts)
-for blocking text iterators and early playback stops. Realtime ASR is async on
-both client variants. ASR events retain their names and raw dictionary payloads,
-including the deprecated `UNACCEPTED_TERMS_ERROR` callback alias.
+In a standalone script, put the complete session workflow in an async function
+and call it once with `asyncio.run(main())`. Keep connection creation, audio
+sending, transcript handling, and session cleanup on that same event loop.
+In an application or notebook with a running event loop, await the workflow
+directly instead of calling `asyncio.run()`. Close the live session before
+leaving the client context; closing the client only closes its HTTP transports.
 
 ## Configuration
 
@@ -252,8 +275,8 @@ including the deprecated `UNACCEPTED_TERMS_ERROR` callback alias.
 | --- | --- |
 | Default API key | `AVARTHA_API_KEY`, read at construction |
 | Default platform root | `AVARTHA_BASE_URL`, or `https://platform.preview.avartha.ai` |
-| Default inference tier | `serverless`; use `tier="dedicated"` for dedicated inference |
-| Explicit `OpenAI(base_url=...)` | Full base including `/inference/{tier}/openai/v1` |
+| Inference tier | `serverless` only; other values raise `ConfigurationError` locally |
+| Explicit `OpenAI(base_url=...)` | Full base including `/inference/serverless/openai/v1` |
 | Explicit OpenAI `websocket_base_url` | Optional `wss://` service base before `/realtime`; other schemes are rejected |
 | Explicit `ElevenLabs(base_url=...)` | Speech service root before `/v1` |
 | Speech URL override | Explicit `base_url`, then `AVARTHA_ELEVENLABS_BASE_URL`, then the derived platform URL |
@@ -261,10 +284,12 @@ including the deprecated `UNACCEPTED_TERMS_ERROR` callback alias.
 | Existing vendor key/URL variables | Update to Avartha variables or explicit arguments |
 | Model and voice names | Use IDs supported by the configured service; no automatic mapping |
 
-Explicit protocol URLs take precedence over `tier`. Proxy path prefixes are
-preserved. Without a WebSocket override, the SDK derives a WS/WSS address from
-the HTTP/HTTPS service base. Avartha keys are never routed to an implicit hosted
-OpenAI or ElevenLabs endpoint.
+Explicit protocol URLs override the derived service URL. Only serverless
+inference is supported: unsupported `tier` values are rejected even with a URL
+override, and dedicated inference URLs are rejected before any request. Proxy
+path prefixes are preserved. Without a WebSocket override, the SDK derives a
+WS/WSS address from the HTTP/HTTPS service base. Avartha keys are never routed
+to an implicit hosted OpenAI or ElevenLabs endpoint.
 
 Speech clients also accept `environment` as a service URL or URL-valued enum
 when `base_url` is omitted. Update any vendor environment value to your Avartha

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/docs/platform.md

@@ -21,7 +21,7 @@ and lists, preserving the server's fields.
 ## Workspace administration
 
 The platform calls workspaces `organizations`. Use the same ID returned by
-`organizations.list()` wherever an endpoint method takes `workspace_id`.
+`organizations.list()` wherever a method takes `workspace_id`.
 
 ```python
 from avartha import Control
@@ -87,7 +87,7 @@ asyncio.run(main())
   change or remove other admins. The server refuses removing or demoting the
   last owner, including through `leave`, with a conflict.
 - New customer workspaces start with a serverless-only, zero-budget allocation.
-  Creation alone does not provide inference credits or dedicated capacity.
+  Creation alone does not provide inference credits.
 - Targeted customer invitations require a workspace member-allocation policy
   and a valid member entitlement policy. Email delivery requires server email
   configuration.
@@ -95,40 +95,6 @@ asyncio.run(main())
   keys requires an interactive browser session and is not available through
   this bearer-key client.
 
-## Dedicated endpoints
-
-`control.endpoints` supports `create`, `get`, `list`, `management`, `stop`,
-`delete`, `update_scaling`, `update_routing`, and `wait_until_ready`.
-[The provisioning example](../examples/endpoints.py) takes a workspace, model,
-name, and SKU JSON and requests GPU capacity. The endpoint remains running
-until explicitly stopped.
-
-Creation persists launch intent and returns immediately. Readiness waiting is
-explicit and requires a `running` endpoint with an accepting replica:
-
-```python
-from avartha import Control
-
-with Control() as client:
-    ready = client.endpoints.wait_until_ready(
-        "your-endpoint-id",
-        timeout=600,
-        poll_interval=2,
-    )
-    print(ready)
-```
-
-The waiter raises `EndpointFailedError` if the endpoint fails, stops, or starts
-stopping. The polling budget caps each HTTP timeout to the remaining time.
-HTTP timeouts are per-phase inactivity timeouts, not a strict total wall-clock
-deadline. Network errors propagate. Async waits support normal asyncio
-cancellation.
-
-Scaling and routing updates require `expected_generation` and `policy`.
-Read the current policy generation through `management` before an update.
-A stale generation returns a conflict; re-read state before deciding whether
-to submit another update.
-
 ## Errors and other routes
 
 `PlatformAPIError` retains `status_code`, `body`, `field_errors`, `request_id`,
@@ -151,7 +117,7 @@ The combined client accepts `openai_options`, `elevenlabs_options`, and
 `control_options` dictionaries for transport and timeout settings. Use its
 named arguments for service URLs and keys. Set `elevenlabs_api_key` when the
 voice service uses a different credential; otherwise it receives the Avartha
-key. The speech URL defaults to the same platform root and tier; use
+key. The speech URL defaults to serverless inference on the same platform root; use
 `elevenlabs_base_url` to select a separate compatible service.
 
 Use context managers or call `close()` (`await close()` for async clients).

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/docs/pypi.md

@@ -16,9 +16,10 @@ 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.
+Clients default to the preview platform and support only serverless inference.
+Set `AVARTHA_BASE_URL` for another environment. Use model and voice IDs available
+to your workspace. Unsupported tier values and dedicated inference URLs raise
+`ConfigurationError` locally before any request.
 
 ## Discover models
 
@@ -76,7 +77,7 @@ Inference consumes credits.
 | 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` |
+| Workspaces, members, invitations | `Control` / `AsyncControl` |
 | Combined inference and management | `Avartha` / `AsyncAvartha` |
 
 Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha/_config.py

@@ -8,12 +8,28 @@ from urllib.parse import urlsplit, urlunsplit
 
 import httpx
 
-Tier = Literal["serverless", "dedicated"]
+Tier = Literal["serverless"]
 DEFAULT_BASE_URL = "https://platform.preview.avartha.ai"
 
 
 class ConfigurationError(ValueError):
-    """Missing credentials or an invalid service URL."""
+    """Missing credentials, an unsupported tier, or an invalid service URL."""
+
+
+def validate_tier(tier: Tier) -> None:
+    if tier != "serverless":
+        raise ConfigurationError(
+            "Only tier='serverless' is supported. Dedicated capacity is unavailable."
+        )
+
+
+def reject_dedicated_url(value: str) -> str:
+    """Reject the dedicated inference route, including behind a proxy prefix."""
+    if re.search(r"(?:^|/)inference/dedicated(?:/|$)", httpx.URL(value).path):
+        raise ConfigurationError(
+            "Dedicated capacity is unavailable. Use a serverless inference URL."
+        )
+    return value
 
 
 def api_key(value: str | None) -> str:
@@ -41,12 +57,13 @@ def http_url(value: str) -> str:
             or (parts.port is not None and not 1 <= parts.port <= 65535)
         ):
             raise ValueError("Invalid URL authority")
-        return str(httpx.URL(value)).rstrip("/")
+        normalized = str(httpx.URL(value)).rstrip("/")
     except (ValueError, httpx.InvalidURL):
         raise ConfigurationError(
             "Use an absolute http(s) base URL without credentials, query, fragment, "
             "whitespace, or backslashes."
         ) from None
+    return reject_dedicated_url(normalized)
 
 
 def platform_url(value: str | None = None) -> str:
@@ -60,20 +77,18 @@ def platform_url(value: str | None = None) -> str:
 
 
 def openai_url(root: str | None = None, tier: Tier = "serverless") -> str:
-    if tier not in {"serverless", "dedicated"}:
-        raise ConfigurationError("tier must be 'serverless' or 'dedicated'.")
-    return f"{platform_url(root)}/inference/{tier}/openai/v1"
+    validate_tier(tier)
+    return f"{platform_url(root)}/inference/serverless/openai/v1"
 
 
 def elevenlabs_url(
     value: str | None = None, *, root: str | None = None, tier: Tier = "serverless"
 ) -> str:
+    validate_tier(tier)
     override = value if value is not None else os.getenv("AVARTHA_ELEVENLABS_BASE_URL")
     if override is not None:
         return http_url(override)
-    if tier not in {"serverless", "dedicated"}:
-        raise ConfigurationError("tier must be 'serverless' or 'dedicated'.")
-    return f"{platform_url(root)}/inference/{tier}/elevenlabs"
+    return f"{platform_url(root)}/inference/serverless/elevenlabs"
 
 
 def websocket_url(value: str) -> str:
@@ -147,4 +162,4 @@ def websocket_override(value: str) -> str:
             "websocket_base_url must be the service base before /realtime; "
             "the SDK appends /realtime when connecting."
         )
-    return not_vendor_host(normalized, field="websocket_base_url")
+    return not_vendor_host(reject_dedicated_url(normalized), field="websocket_base_url")

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha/client.py

@@ -16,6 +16,12 @@ class Avartha:
 
     openai_options, elevenlabs_options and control_options are forwarded to
     their respective constructors (for timeouts, transports, retry settings).
+
+    Live STT through elevenlabs.speech_to_text.realtime remains asynchronous.
+    Await connect(), send(), commit(), and the transcription connection's close().
+    Register callbacks with on() without awaiting. Use AsyncAvartha for an async
+    application.
+    Close live sessions separately before closing this client.
     """
 
     def __init__(
@@ -30,6 +36,9 @@ class Avartha:
         elevenlabs_options: dict[str, Any] | None = None,
         control_options: dict[str, Any] | None = None,
     ) -> None:
+        _config.validate_tier(tier)
+        for options in (openai_options, elevenlabs_options):
+            _config.validate_tier((options or {}).get("tier", "serverless"))
         key, root = _config.api_key(api_key), _config.platform_url(base_url)
         self._elevenlabs_base_url = _config.elevenlabs_url(
             elevenlabs_base_url, root=root, tier=tier
@@ -99,6 +108,9 @@ class AsyncAvartha:
         elevenlabs_options: dict[str, Any] | None = None,
         control_options: dict[str, Any] | None = None,
     ) -> None:
+        _config.validate_tier(tier)
+        for options in (openai_options, elevenlabs_options):
+            _config.validate_tier((options or {}).get("tier", "serverless"))
         key, root = _config.api_key(api_key), _config.platform_url(base_url)
         self._elevenlabs_base_url = _config.elevenlabs_url(
             elevenlabs_base_url, root=root, tier=tier

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha/elevenlabs.py

@@ -45,6 +45,7 @@ class _Client:
         environment: str | Enum | None = None,
         websocket_limits: WebSocketLimits | None = None,
     ) -> None:
+        _config.validate_tier(tier)
         self.api_key = _config.api_key(api_key)
         if base_url is None and environment is not None:
             base_url = str(environment.value) if isinstance(environment, Enum) else environment

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha/openai.py

@@ -121,6 +121,7 @@ class _Client:
         _enforce_credentials: bool = True,
         tier: Tier = "serverless",
     ) -> None:
+        _config.validate_tier(tier)
         if data_residency is not None:
             raise ConfigurationError(
                 "data_residency selects a vendor host; use an Avartha base_url."

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha/types/realtime/realtime_reasoning_effort.py

@@ -3,4 +3,6 @@
 from typing import Literal, TypeAlias
 
 __all__ = ["RealtimeReasoningEffort"]
-RealtimeReasoningEffort: TypeAlias = Literal["minimal", "low", "medium", "high", "xhigh"]
+RealtimeReasoningEffort: TypeAlias = Literal[
+    "none", "minimal", "low", "medium", "high", "xhigh", "max"
+]

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avartha-python-sdk
-Version: 0.0.4
+Version: 0.0.5
 Summary: Python clients for Avartha Realtime text, streaming speech, and platform management
 Author-email: "Avartha Inc." <team@avartha.ai>
 License-Expression: LicenseRef-Avartha-Proprietary
@@ -47,9 +47,10 @@ 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.
+Clients default to the preview platform and support only serverless inference.
+Set `AVARTHA_BASE_URL` for another environment. Use model and voice IDs available
+to your workspace. Unsupported tier values and dedicated inference URLs raise
+`ConfigurationError` locally before any request.
 
 ## Discover models
 
@@ -107,7 +108,7 @@ Inference consumes credits.
 | 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` |
+| Workspaces, members, invitations | `Control` / `AsyncControl` |
 | Combined inference and management | `Avartha` / `AsyncAvartha` |
 
 Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.5}/src/avartha_python_sdk.egg-info/SOURCES.txt

@@ -8,7 +8,6 @@ docs/compatibility.md
 docs/migration.md
 docs/platform.md
 docs/pypi.md
-examples/endpoints.py
 examples/realtime.py
 examples/realtime_asr.py
 examples/tts.py

avartha_python_sdk-0.0.4/examples/endpoints.py

@@ -1,39 +0,0 @@
-"""Provision a dedicated endpoint. This requests GPU capacity and may incur costs.
-
-Set AVARTHA_API_KEY and optionally AVARTHA_BASE_URL.
-Run: python examples/endpoints.py WORKSPACE_ID MODEL_SLUG NAME sku.json
-The SKU JSON contains provider, cpu (cores, memory_gb), and gpu (kind, count).
-Use client.control.catalog.skus(provider=...) for provider-specific options.
-The endpoint remains running after this example exits.
-"""
-
-import argparse
-import json
-from pathlib import Path
-
-from avartha import Avartha
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("workspace")
-    parser.add_argument("model")
-    parser.add_argument("name")
-    parser.add_argument("sku_file", type=Path)
-    args = parser.parse_args()
-    with Avartha() as client:
-        endpoints = client.control.endpoints
-        endpoint = endpoints.create(
-            workspace_id=args.workspace,
-            model_slug=args.model,
-            name=args.name,
-            sku=json.loads(args.sku_file.read_text()),
-        )
-        print("Created:", endpoint["id"])
-        ready = endpoints.wait_until_ready(endpoint["id"], timeout=600)
-        print("Ready:", ready)
-        print("To stop: client.control.endpoints.stop(endpoint_id)")
-
-
-if __name__ == "__main__":
-    main()