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

{avartha_python_sdk-0.0.4 → avartha_python_sdk-0.0.6}/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.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avartha-python-sdk
-Version: 0.0.4
+Version: 0.0.6
 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.6}/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,20 @@ 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.
+
+Current ASR models require 16 kHz mono PCM16 audio. Convert other formats or
+sample rates before sending audio chunks; the SDK does not resample them.
+Await a committed transcript before closing the session.
 [The complete example](examples/realtime_asr.py) reads a WAV file, registers
 transcript/error callbacks, streams chunks, commits, and closes the connection:
 
@@ -219,12 +231,20 @@ transcript/error callbacks, streams chunks, commits, and closes the connection:
 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.
+Current ASR models reject nonempty `previous_text`. Omit it from
+`connection.send`; the SDK sends `null`. An empty string is also accepted.
+For vocabulary hints on supported models, pass `keyterms` in the connection
+options instead.
 
 File-based HTTP `speech_to_text.convert` is retired on managed inference.
 
+Connection options cover background speech filtering, vocabulary hints,
+manual/VAD commits, Smart Turn, word log probabilities, timestamps, and speaker
+labels on supported models. Register `RealtimeEvents.WARNING` for nonfatal
+warnings, including unavailable timing metadata. See
+[ASR options and callbacks](docs/migration.md#recognition-and-context-hints)
+for configuration and server requirements.
+
 ## Agents
 
 Agent management, tools, knowledge bases, and conversation sessions/history are
@@ -354,10 +374,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 +401,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 +413,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.6}/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,18 +115,22 @@ 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 |
 | `voices.settings.get(voice_id)` | `/v1/voices/{voice_id}/settings` | Same; server reports supported `speed=1.0` |
-| `speech_to_text.languages.list(model_id=...)` | `/v1/speech-to-text/languages` | A routable ASR model; runtime reports supported languages or unavailable hints |
+| `speech_to_text.languages.list(model_id=...)` | `/v1/models` | Selects the ASR model's language metadata from the speech catalog |
 
 All methods have sync and async variants and typed raw-response access.
+The language helper maps catalog `language_id` entries to `code`. An empty
+language list means hints are unsupported; missing metadata or an unavailable
+model raises `ApiError`. Its raw-response wrapper retains the catalog response's
+HTTP status and headers while exposing the selected model's typed language list.
 Model/voice methods retain upstream signatures; language discovery is an
 Avartha extension. Pass the TTS `model_id` through
 `request_options.additional_query_parameters`, especially when multiple TTS
@@ -258,15 +262,50 @@ Audio formats and `voice_settings` depend on the selected model. Specifying an
 option in the SDK does not make it available on the server. Runnable examples:
 [single-context](../examples/tts.py), [multi-context](../examples/tts_multi_context.py).
 
+## Realtime ASR
+
+Current ASR models require 16 kHz mono PCM16 audio. The SDK retains the other
+`AudioFormat` enum values for protocol compatibility; their presence does not
+imply server support. Audio-chunk mode sends samples unchanged. Convert the
+source before sending, or use URL mode, which requires FFmpeg and converts to
+16 kHz mono PCM16.
+
+The SDK also preserves `previous_text` on audio chunks, but current ASR models
+accept only omission, `null`, or an empty string. Nonempty values are rejected.
+Vocabulary hints use `keyterms` on models that support them.
+
+The SDK forwards background filtering (`filter_background_audio`), vocabulary
+hints (`keyterms`), manual/VAD commit controls, and `include_timestamps`.
+It additionally exposes Avartha's `diarize`, `include_logprobs`, `turn_model`,
+and `turn_threshold` options on both audio-chunk and URL connections. These
+extensions are not a claim of upstream ElevenLabs realtime feature parity.
+Omitted extension options are not added to the query; explicit booleans are
+sent as `true` or `false`.
+
+The server validates feature combinations and model availability. Diarization
+requires timestamps and a model with speaker-label support. Timestamps also
+depend on language support. Smart Turn requires VAD mode and a server with
+`smart_turn_v3` enabled; `turn_threshold` is only meaningful in that mode.
+Background filtering and vocabulary hints also depend on the model.
+
+Transcript callbacks preserve server dictionaries, including `words` with
+timing, speaker labels, and log probabilities when supplied.
+`RealtimeEvents.WARNING` delivers nonfatal warnings without also dispatching
+`ERROR`. A timing warning can replace a timed result; the preceding plain
+committed transcript remains usable. See the
+[ASR options and event guidance](migration.md#recognition-and-context-hints).
+
 ## 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.6}/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
@@ -191,9 +191,7 @@ with ElevenLabs() as client:
     if voices:
         voice = client.voices.get(voices[0].voice_id, request_options=options)
         settings = client.voices.settings.get(voice.voice_id, request_options=options)
-    languages = client.speech_to_text.languages.list(
-        model_id="mistralai/voxtral-mini-4b-realtime-2602"
-    )
+    languages = client.speech_to_text.languages.list(model_id="YOUR_ASR_MODEL_ID")
 ```
 
 Use `AsyncElevenLabs` with `async with` and `await` for each call. Each resource
@@ -213,8 +211,10 @@ available as `error.__cause__`.
 `model_id` is an Avartha query extension for voice discovery. Specify it when
 more than one TTS model is available. The platform supports `search`, `page_size`,
 `next_page_token`, and `include_total_count` on `voices.search`; other vendor
-filters are forwarded and may be rejected by the server. ASR language hints
-can be unavailable, with `language_hints_supported=False` and an empty list.
+filters are forwarded and may be rejected by the server. The language helper
+selects the requested ASR model from `models.list()`. An empty language list
+means hints are unsupported (`language_hints_supported=False`); a missing
+model or missing language metadata raises `ApiError` instead.
 See [supported HTTP endpoints and server prerequisites](compatibility.md#speech-http-discovery).
 
 ### Speech-specific configuration
@@ -229,22 +229,142 @@ 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.
 
-`previous_text` supplies optional text context for transcription. When omitted,
-Avartha sends `null`, meaning no context. Audio-send code can omit the field:
+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.
+
+Current ASR models require raw 16 kHz mono PCM16 samples without a file header.
+For audio chunks, select `AudioFormat.PCM_16000` and `sample_rate=16000`, and
+convert other formats or sample rates before sending. The SDK does not
+resample chunks or convert their encoding. URL mode uses FFmpeg to convert the
+source to the required format and requires FFmpeg on `PATH`.
+
+Nonempty `previous_text` is unsupported by current ASR models. The SDK
+preserves this protocol field, but the server rejects nonempty values rather
+than using them as context. Omission, `None`, or an empty string supplies no
+context. Use `keyterms` in the connection options for vocabulary hints on
+supported models. Audio-send code can omit `previous_text`; the SDK sends `null`:
 
 ```python
 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)`.
+
+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.
+
+#### Recognition and context hints
+
+Pass options to `realtime.connect()` using `RealtimeAudioOptions` for audio
+chunks or `RealtimeUrlOptions` for an audio URL. The SDK forwards these settings;
+the selected model and server must support them.
+
+`filter_background_audio=True` enables experimental background speech filtering
+on supported models. Use it to reduce transcription of background speakers.
+It defaults to off and is separate from microphone echo cancellation.
+
+Use `keyterms=["Avartha", "Kubernetes"]` for vocabulary hints on models that
+support them. The SDK sends each term as a separate query parameter and handles
+URL encoding. Hints do not guarantee a spelling and are not a free-form prompt.
+`language_code` can constrain recognition to a supported language; use
+`speech_to_text.languages.list(model_id=...)` to check language support.
+
+#### Ending an utterance
+
+`commit_strategy=CommitStrategy.MANUAL` is the default. Send audio, then call
+`await connection.commit()` when your application decides the utterance is
+complete. This waits for the send, not the transcript: wait for
+`RealtimeEvents.COMMITTED_TRANSCRIPT` before treating transcription as complete.
+Do not commit an empty audio buffer as a completion check.
+
+For automatic commits, use `commit_strategy=CommitStrategy.VAD`. Set
+`turn_model="silence"` for silence-based turn detection; omitting it uses the
+server's default. Tune `vad_silence_threshold_secs` for the silence
+wait and `vad_threshold` for speech detection sensitivity. VAD controls require
+VAD mode; omit them in manual mode.
+
+On servers supporting Smart Turn, add `turn_model="smart_turn_v3"`. It uses an
+end-of-turn model to judge whether the speaker has finished, with a silence
+timeout as fallback. `turn_threshold` controls its decision threshold, defaults
+to `0.5`, and must be strictly between `0` and `1`. Only pass this threshold with
+Smart Turn. For example, inside an async client context:
 
-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.
+```python
+from avartha import AudioFormat, CommitStrategy, RealtimeAudioOptions
+
+options = RealtimeAudioOptions(
+    model_id="YOUR_ASR_MODEL_ID",
+    audio_format=AudioFormat.PCM_16000,
+    sample_rate=16000,
+    commit_strategy=CommitStrategy.VAD,
+    turn_model="smart_turn_v3",
+    turn_threshold=0.5,
+)
+connection = await client.speech_to_text.realtime.connect(options)
+```
+
+#### Transcript details
+
+`include_logprobs=True` requests word log probabilities in final transcripts.
+These are model scores, not calibrated confidence percentages. This option does
+not enable timestamps. `include_timestamps=True` requests a separate
+`RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS` event after the plain
+committed transcript. Use it to enrich the same utterance, not append a duplicate.
+
+`diarize=True` requests speaker labels and requires `include_timestamps=True`.
+On supported models, timed `words` entries can include `speaker_id` alongside
+`start` and `end`. Speaker labels may be absent if diarization fails; timestamps
+can still be returned. These three options default to off. For a model and
+language that support the requested details:
+
+Add `include_timestamps=True`, `diarize=True`, and `include_logprobs=True` to
+the `RealtimeAudioOptions` above before connecting. Omit options you do not need.
+
+Register handlers before sending audio. Callbacks receive the unmodified server
+dictionary, including word scores, timestamps, and speaker labels:
+
+```python
+from avartha import RealtimeEvents
+
+connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, lambda event: print(event["text"]))
+connection.on(
+    RealtimeEvents.COMMITTED_TRANSCRIPT_WITH_TIMESTAMPS,
+    lambda event: print(event.get("words", [])),
+)
+connection.on(RealtimeEvents.WARNING, lambda event: print("Warning:", event))
+connection.on(RealtimeEvents.ERROR, lambda event: print("Error:", event))
+```
+
+If timing cannot be produced, the server can send a `WARNING` instead of the
+timed event. Retain the plain committed transcript. Warnings do not trigger the
+`ERROR` callback or close the SDK connection. When waiting for optional metadata,
+handle both the timed event and the warning, and use an application timeout.
+Do not close immediately after the plain final if you still need its metadata.
 
 ## Configuration
 
@@ -252,8 +372,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 +381,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.6}/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.6}/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.6}/examples/realtime_asr.py

@@ -1,7 +1,8 @@
-"""Stream mono, signed 16-bit PCM WAV audio with the ElevenLabs ASR protocol.
+"""Stream 16 kHz mono, signed 16-bit PCM WAV audio with the ElevenLabs ASR protocol.
 
 Set AVARTHA_API_KEY and optionally AVARTHA_BASE_URL.
-Run: python examples/realtime_asr.py MODEL_ID speech.wav
+Run: python examples/realtime_asr.py MODEL_ID speech-16k.wav
+Convert other sample rates before running; this example does not resample audio.
 """
 
 import argparse
@@ -39,6 +40,7 @@ async def run(model: str, audio_path: str):
 
             connection.on(RealtimeEvents.PARTIAL_TRANSCRIPT, lambda event: print(event["text"]))
             connection.on(RealtimeEvents.COMMITTED_TRANSCRIPT, transcript)
+            connection.on(RealtimeEvents.WARNING, lambda event: print("Warning:", event))
             connection.on(RealtimeEvents.ERROR, failed)
             try:
                 while chunk := audio.readframes(sample_rate // 10):