avartha-python-sdk 0.0.7__tar.gz → 0.0.8__tar.gz

{avartha_python_sdk-0.0.7/src/avartha_python_sdk.egg-info → avartha_python_sdk-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avartha-python-sdk
-Version: 0.0.7
+Version: 0.0.8
 Summary: Python clients for Avartha Realtime text, streaming speech, and platform management
 Author-email: "Avartha Inc." <team@avartha.ai>
 License-Expression: LicenseRef-Avartha-Proprietary
@@ -33,11 +33,12 @@ Dynamic: license-file
 
 Synchronous and asynchronous Python clients for Avartha Realtime text,
 streaming speech, and platform management. Requires Python 3.12+.
+The guides and examples below use SDK 0.0.7 or later.
 
 ## Install
 
 ```sh
-python -m pip install avartha-python-sdk
+python -m pip install --upgrade 'avartha-python-sdk>=0.0.7'
 ```
 
 Configure your Avartha API key and platform root:
@@ -55,15 +56,18 @@ to your workspace. Unsupported tier values and dedicated inference URLs raise
 ## Discover models
 
 ```python
-from avartha import OpenAI
+from avartha import Avartha
 
-with OpenAI() as client:
+with Avartha() as client:
     for model in client.models.list():
         print(model.id, model.to_dict().get("protocols", []))
+    for model in client.elevenlabs.models.list():
+        print(model.model_id, getattr(model, "protocols", []))
 ```
 
-Choose a model supporting `openai_realtime` for text, `elevenlabs_tts` for
-speech synthesis, or `elevenlabs_asr` for speech recognition.
+`client.models` lists Voice LLMs; choose `openai_realtime` for text.
+`client.elevenlabs.models` lists speech models; choose `elevenlabs_tts` for
+speech synthesis or `elevenlabs_asr` for speech recognition.
 
 ## Generate text
 
@@ -111,11 +115,10 @@ Inference consumes credits.
 | Workspaces, members, invitations | `Control` / `AsyncControl` |
 | Voice agents: create, edit, publish, restore, delete | `Control` / `AsyncControl`: `voice_agents` |
 | Live conversations with published agents | `avartha.conversational_ai`: `Conversation`, `AsyncConversation` |
-| Placing phone calls from Twilio numbers | `ElevenLabs` / `AsyncElevenLabs`: `conversational_ai.twilio.outbound_call` |
 | Combined inference and management | `Avartha` / `AsyncAvartha` |
 
-Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,
-and file transcription are unavailable. ElevenLabs-schema agent management is not
+This SDK provides model inference over WebSockets; it does not wrap HTTP
+Chat Completions, Responses, speech synthesis, or file transcription. ElevenLabs-schema agent management is not
 implemented, and accessing it under `conversational_ai` raises `NotImplementedError`.
 
 ## Migrating and handling errors
@@ -140,4 +143,4 @@ never retried automatically.
 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.
+and platform-management guides and run the text, speech, and voice-agent examples.

{avartha_python_sdk-0.0.7 → avartha_python_sdk-0.0.8}/README.md

@@ -4,6 +4,7 @@
 
 Synchronous and asynchronous Python clients for Avartha Realtime LLMs,
 streaming speech, and platform management. Requires Python 3.12+.
+The guides and examples below use SDK 0.0.7 or later.
 
 **Familiar Python interfaces for OpenAI Realtime and ElevenLabs speech.** Change
 client, type, and exception imports, then configure Avartha credentials, URLs,
@@ -20,9 +21,11 @@ and model/voice IDs. The supported APIs use the same method names and event loop
 ```
 
 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.
+streaming speech, HTTP discovery, and platform management. This SDK uses
+WebSockets for model inference. It does not wrap HTTP Chat Completions,
+Responses, or speech synthesis. Enabled platform HTTP endpoints have their
+own model and workspace prerequisites. See the guides below for supported
+features and migration steps.
 
 ## Documentation
 
@@ -36,7 +39,7 @@ unavailable. See the guides below for supported features and migration steps.
 Install from [PyPI](https://pypi.org/project/avartha-python-sdk/):
 
 ```sh
-python -m pip install avartha-python-sdk
+python -m pip install --upgrade 'avartha-python-sdk>=0.0.7'
 ```
 
 Set your Avartha API key and platform root. Update `AVARTHA_BASE_URL` to match
@@ -88,16 +91,19 @@ and response on the same connection to preserve conversation state.
 To discover available models and their enabled protocols:
 
 ```python
-from avartha import OpenAI
+from avartha import Avartha
 
-with OpenAI() as client:
+with Avartha() as client:
     for model in client.models.list():
         print(model.id, model.to_dict().get("protocols", []))
+    for model in client.elevenlabs.models.list():
+        print(model.model_id, getattr(model, "protocols", []))
 ```
 
 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`.
+the example IDs with models returned for your key. `client.models` lists
+Voice LLMs; choose `openai_realtime` for text. `client.elevenlabs.models` lists
+speech models; choose `elevenlabs_tts` or `elevenlabs_asr` for speech.
 
 ## Async usage
 
@@ -169,6 +175,7 @@ G.711 (`ulaw_8000`, `alaw_8000`). This example writes 24 kHz PCM to a WAV file:
 
 ```python
 import wave
+from contextlib import closing
 from avartha import ElevenLabs
 
 with ElevenLabs() as client:
@@ -178,7 +185,7 @@ with ElevenLabs() as client:
         output_format="pcm_24000",
         text=iter(["Welcome. ", "How can I help?"]),
     )
-    with wave.open("welcome.wav", "wb") as output:
+    with closing(audio), wave.open("welcome.wav", "wb") as output:
         output.setnchannels(1)
         output.setsampwidth(2)
         output.setframerate(24000)
@@ -225,8 +232,9 @@ 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.
+ASR accepts mono PCM16 at 8, 16, 22.05, 24, 44.1, or 48 kHz, and 8 kHz mu-law.
+Choose the `AudioFormat` and `sample_rate` that match your samples; the server
+resamples them, and the SDK sends chunks unchanged.
 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:
@@ -294,21 +302,6 @@ with ElevenLabs() as client:
     conversation.wait_for_session_end()
 ```
 
-An agent can also call someone from one of the workspace's Twilio numbers. Pass an
-`idempotency_key`, so a retry can't ring them twice, and check `placed.success`:
-
-```python
-placed = client.conversational_ai.twilio.outbound_call(
-    agent_id="your-agent-id",
-    agent_phone_number_id="your-twilio-number-id",
-    to_number="+14155550100",
-    idempotency_key="order-1042-reminder",
-)
-```
-
-See [placing a phone call](docs/voice-conversations.md#placing-a-phone-call) for its
-prerequisites and how to follow the call.
-
 ElevenLabs-schema agent management, tools, and knowledge bases are not implemented.
 Accessing them under `client.conversational_ai` raises `NotImplementedError`.
 

{avartha_python_sdk-0.0.7 → avartha_python_sdk-0.0.8}/docs/compatibility.md

@@ -1,6 +1,7 @@
 # Compatibility and server support
 
-Avartha supports the OpenAI Python 3.13.0 Realtime text interface and the
+This guide covers Avartha Python SDK 0.0.7 or later. Avartha supports the
+OpenAI Python 3.13.0 Realtime text interface and the
 ElevenLabs Python 2.68.0 realtime speech and discovery interfaces. Neither
 vendor SDK needs to be installed. Import clients, types, and exceptions from
 Avartha; see the [migration guide](migration.md).
@@ -9,27 +10,29 @@ Avartha; see the [migration guide](migration.md).
 
 SDK support and server availability are separate. Select a model available to
 your workspace on serverless inference, and use only the features that model supports.
-Avartha managed inference uses WebSockets. Discovery and platform management
-use HTTP.
+These SDK model clients provide inference over WebSockets. Discovery and platform
+management use HTTP. The platform also has enabled HTTP inference routes that
+this SDK does not wrap: OpenAI speech/batch and Decisions, plus Chat Completions
+for authorized OpenRouter-provider workspaces. Those routes do not imply that
+ordinary workspace keys can use HTTP LLM inference.
 
 | 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 |
 | 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 |
+| Chat Completions, Responses, SSE, and OpenAI HTTP speech | No SDK wrappers | Enabled platform HTTP routes have separate prerequisites; use Realtime for this SDK’s model clients |
 | Speech models and voices | Typed sync/async HTTP discovery | A visible speech model; voice discovery requires a routable TTS model |
 | ASR languages | Sync/async `speech_to_text.languages.list(model_id=...)` | A routable ASR model; language hints depend on the model |
 | Single-context TTS | Sync/async `convert_realtime` | A TTS model and voice; the runtime converts to the selected PCM, MP3 or G.711 format |
 | Multi-context TTS | Sync/async `connect_multi_context` | A model supporting multiple contexts; each utterance needs a new context ID. Character timestamps need a timestamp-capable model |
 | 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 |
+| HTTP TTS and file transcription | No SDK wrappers | Use these SDK realtime speech methods, or an explicitly enabled platform HTTP route |
 | Live conversations and their history | Sync/async `Conversation`, `AsyncConversation`, and `conversational_ai.conversations` | A published agent and an API key for its workspace; see [voice conversations](voice-conversations.md) |
-| Placing phone calls | Sync/async `conversational_ai.twilio.outbound_call` | Outbound calling enabled, a key with `voice_calls_place`, a Twilio number, and a published agent; see [placing a phone call](voice-conversations.md#placing-a-phone-call) |
 | ElevenLabs-schema agents, tools, knowledge bases | Not implemented | Accessing them under `conversational_ai` raises `NotImplementedError` |
-| Avartha voice agents: create, read, edit, publish, restore, delete | Sync/async `Control.voice_agents` | An API key with voice-agent management access to that workspace; the feature enabled; capacity to publish |
+| Avartha voice agents: create, read, edit, publish, restore, delete | Sync/async `Control.voice_agents` | An API key with voice-agent management access to that workspace; capacity to publish |
 | 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 |
+| API-key administration | No convenience resource; verified routes can use `Control.request` | A workspace-bound key with `keys` access and a creator who is still an Owner or Admin, or a console session |
 
 See [platform management](platform.md) for workspace roles, invitation
 requirements, voice agents, and permissions.
@@ -53,6 +56,13 @@ serialization methods. The server must implement each requested feature.
 Inspect `response.done.response.status` to distinguish successful completion
 from failure, cancellation, or an incomplete response.
 
+A new connection can rebuild a saved conversation on a compatible model.
+Before its first `response.create`, append the saved items in order: assistant
+messages with `role: "assistant"` and `output_text` content, and each tool call
+as a `function_call` item (`call_id`, `name`, and JSON-object `arguments`)
+followed by its `function_call_output`. Wait for each item's acknowledgement
+before requesting a reply. This rebuilds the input history, not the old session.
+
 ### Sampling controls
 
 Avartha adds sampling controls to `session.update` and `response.create`:
@@ -88,6 +98,32 @@ or queued, including through `send_raw()`:
 Active penalties also require deployment support; otherwise the server refuses
 them with an `error` event. Speech-to-text connections have no temperature setting.
 
+### Native options beyond the typed schema
+
+The SDK's public types cover its supported subset of the OpenAI schema and the
+sampling controls above. Some Avartha Realtime extensions, including
+`include_reasoning` and `reasoning.thinking_enabled`, are not yet declared in
+those types. A supported runtime can receive them as explicit JSON:
+
+```python
+import json
+
+await connection.send_raw(
+    json.dumps(
+        {
+            "type": "session.update",
+            "session": {"type": "realtime", "include_reasoning": True},
+        }
+    )
+)
+```
+
+This opts into reasoning output without changing the model's reasoning effort.
+The synchronous connection uses the same call without `await`. Raw frames still
+pass the SDK's text-only and sampling checks, and the server validates all
+remaining fields. A field's absence from the Python type does not establish
+server support; check the selected model and platform protocol documentation.
+
 ### Unsupported operations
 
 Explicit audio/transcription/image requests raise `UnsupportedOperationError`
@@ -242,6 +278,22 @@ Out-of-range `inactivity_timeout` values, a non-boolean `sync_alignment`, and
 `sync_alignment=True` with MP3 raise `ValueError` before connecting. For
 `convert_realtime`, that happens when iteration starts.
 
+### Voice settings, warnings, and other query parameters
+
+ElevenLabs' `stability`, `similarity_boost`, and `style` (finite numbers from 0
+to 1) and `use_speaker_boost` (a boolean) are accepted in `voice_settings` for
+compatibility, but they do not change synthesis. `speed` must be omitted or 1.0.
+Other names, types, and ranges are refused. When accepted settings have no
+effect, the runtime sends a `warning` once per connection. The SDK logs it on
+the `avartha._realtime_tts` logger at `WARNING` level and keeps streaming: a
+warning never raises or settles a context.
+
+Pass other documented stream parameters, such as `language_code`, in
+`request_options={"additional_query_parameters": {...}}`. Values there override
+the SDK's own query values, and `None` omits one. Some models cannot detect the
+language of streamed text, so they refuse it unless `language_code` is set;
+send `"en"` for English text.
+
 Use `contextlib.closing(audio)` for the sync iterator or
 `contextlib.aclosing(audio)` for the async iterator when playback may stop early.
 Closing the iterator closes the socket and waits for its sender to stop. Started
@@ -343,8 +395,11 @@ the server. Runnable examples:
 ## Realtime ASR
 
 Audio-chunk mode sends samples unchanged. Supply matching `audio_format` and
-`sample_rate`; mismatches raise `ValueError` before opening a socket. Supported
-encodings and rates depend on the server. URL mode requires FFmpeg and converts
+`sample_rate`; mismatches raise `ValueError` before opening a socket. Every
+`AudioFormat` value is accepted: mono PCM16 at 8, 16, 22.05, 24, 44.1, or 48 kHz,
+and 8 kHz mu-law (`ULAW_8000`). The server resamples them for recognition. Send
+raw samples without a file header; a chunk can hold at most 320,000 decoded bytes
+and 160,000 samples, and must end on a sample boundary. URL mode requires FFmpeg and converts
 the source to 16 kHz mono PCM16. After a successful, nonempty source reaches EOF,
 the SDK commits the final turn and keeps receiving transcript events until the
 application closes the connection. FFmpeg failures emit `RealtimeEvents.ERROR`.
@@ -454,4 +509,6 @@ committed transcript remains usable. See the
   fence. Pass `organization` or `project` explicitly to set them.
 - The ASR token option is preserved, including suppression of the API-key header
   when a token is supplied. Token issuance is a separate server prerequisite.
-  Agent signed-URL handling will be implemented with the future Agents client.
+  Published-agent signed URLs are available through
+  `conversational_ai.conversations.get_signed_url` and
+  `Conversation(requires_auth=True)`; see [voice conversations](voice-conversations.md).

{avartha_python_sdk-0.0.7 → avartha_python_sdk-0.0.8}/docs/migration.md

@@ -7,16 +7,17 @@ URLs, and model/voice IDs. Keep the supported realtime calls and event loops.
 The supported interfaces match OpenAI Python 3.13.0 and ElevenLabs Python 2.68.0.
 Neither vendor SDK needs to be installed to use Avartha.
 
-Client compatibility does not add server endpoints. Current managed inference
-supports WebSocket inference and HTTP discovery. HTTP speech synthesis/file
-transcription, Chat Completions, and Responses are retired. See [SDK support and server prerequisites](compatibility.md).
+This guide uses SDK 0.0.7 or later. Its model clients provide WebSocket
+inference and HTTP discovery. HTTP inference wrappers are outside this SDK
+subset; enabled platform HTTP endpoints have separate prerequisites. See
+[SDK support and server prerequisites](compatibility.md).
 
 ## From OpenAI Realtime
 
 Install the package:
 
 ```sh
-python -m pip install avartha-python-sdk
+python -m pip install --upgrade 'avartha-python-sdk>=0.0.7'
 ```
 
 Then change the client import:
@@ -105,8 +106,9 @@ application uses it.
 
 ### Existing HTTP inference applications
 
-Applications using Chat Completions, Responses, SSE, or HTTP speech inference
-must switch to the corresponding Realtime protocol. Calls to OpenAI-compatible
+Applications moving HTTP inference code to these SDK model clients use the
+corresponding Realtime protocol. A direct platform HTTP integration uses its
+own documented endpoint and model prerequisites. Calls to OpenAI-compatible
 HTTP inference resources raise `avartha.UnsupportedOperationError` before any
 request is sent, including when a custom service URL is supplied.
 
@@ -165,13 +167,12 @@ use `avartha.ApiError`. WebSocket exceptions retain the `websockets` classes.
 | ASR languages | `speech_to_text.languages.list(model_id=...)` | Typed sync/async Avartha extension |
 | HTTP TTS, file ASR | `text_to_speech.convert`, `text_to_speech.stream`, `speech_to_text.convert` | Unavailable in this SDK |
 | Conversation sessions and history | `conversational_ai.conversation`, `conversational_ai.conversations` | A documented subset; see [voice conversations](voice-conversations.md) |
-| Placing phone calls | `conversational_ai.twilio.outbound_call` | A documented subset; see [placing a phone call](voice-conversations.md#placing-a-phone-call) |
-| Registering Twilio calls | `conversational_ai.twilio.register_call` | Unavailable in this SDK |
 | Agents, tools, knowledge bases | `conversational_ai` | Not implemented |
+| Twilio phone calls | `conversational_ai.twilio` | Unavailable in this SDK |
 
 Replace `avartha.legacy.ElevenLabs` and `avartha.legacy.AsyncElevenLabs` imports
 with `avartha.ElevenLabs` and `avartha.AsyncElevenLabs`.
-Accessing agents, tools, or knowledge bases under `conversational_ai` raises
+Accessing agents, tools, knowledge bases, or `twilio` under `conversational_ai` raises
 `NotImplementedError`; Avartha's own voice agents use a different schema and are managed
 with [`Control.voice_agents`](platform.md#voice-agents). Conversations use
 `avartha.conversational_ai`; call `wait_for_session_start()` before sending, and pass
@@ -264,11 +265,12 @@ 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`.
+ASR accepts raw mono samples without a file header: PCM16 at 8, 16, 22.05, 24,
+44.1, or 48 kHz, or 8 kHz mu-law. Select the matching `AudioFormat` and
+`sample_rate`, such as `AudioFormat.PCM_24000` with `sample_rate=24000`; the
+server resamples them for recognition. The SDK sends chunks unchanged and does
+not convert their encoding. URL mode uses FFmpeg to convert the source to 16 kHz
+PCM16 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
@@ -448,9 +450,10 @@ Speech discovery retries transient HTTP statuses twice by default; use
 `request_options={"max_retries": 0}` to disable retries. Redirects must stay on
 the configured origin. Platform management writes are never retried automatically.
 
-HTTP timeout and retry settings do not configure WebSockets. Use
-`client.realtime.connect(..., max_retries=0)` on OpenAI-compatible clients to
-disable automatic reconnection, and `websocket_connection_options` for
-connection settings. Use `asyncio.timeout` when an async operation needs an
+HTTP timeout and retry settings do not configure WebSockets. Realtime
+reconnection is opt-in through `on_reconnecting`; `max_retries=0` disables
+retries even with a callback. Each reconnect starts a fresh session, so the
+application must restore configuration and conversation history. Use
+`websocket_connection_options` for connection settings. Use `asyncio.timeout` when an async operation needs an
 overall deadline. Close active WebSocket sessions separately, including when
 cancelling or stopping playback early.

{avartha_python_sdk-0.0.7 → avartha_python_sdk-0.0.8}/docs/platform.md

@@ -14,8 +14,11 @@ with Avartha() as client:
     print(models, sizes, organizations)
 ```
 
+These examples use SDK 0.0.7 or later.
+
 `organizations.limits(workspace_id)` returns quota policy, current usage, and
-any pending quota increase request. Management responses are JSON dictionaries
+any pending quota increase request. A null `entitlement_policy` means the
+workspace uses platform defaults, not that it is unlimited. Management responses are JSON dictionaries
 and lists, preserving the server's fields.
 
 ## Workspace administration
@@ -27,7 +30,7 @@ The platform calls workspaces `organizations`. Use the same ID returned by
 from avartha import Control
 
 with Control() as client:
-    workspace = client.organizations.create(name="Research")
+    workspace = client.organizations.list()[0]  # The API key's bound workspace.
     workspace_id = str(workspace["id"])
     client.organizations.update(workspace_id, name="Research team")
     members = client.organizations.members.list(workspace_id)
@@ -38,7 +41,7 @@ with Control() as client:
 | --- | --- |
 | `control.organizations` | `list()`, `get(id)`, `create(name=...)`, `update(id, name=...)`, `delete(id)`, `leave(id)`, `limits(id)` |
 | `control.organizations.members` | `list(id)`, `update(id, user_id, role=...)`, `remove(id, user_id)` |
-| `control.organizations.invitations` | `list(id)`, `create(id, role=..., email=..., entitlement_policy=...)`, `revoke(id, invitation_id)` |
+| `control.organizations.invitations` | `list(id)`, `create(id, role=..., email=...)`, `revoke(id, invitation_id)` |
 | `control.invitations` | `preview(token)`, `accept(token=...)` |
 
 Here, `id` is the organization ID. Roles are `"owner"`, `"admin"`, and
@@ -49,9 +52,9 @@ return `None`. Revoking an invitation returns its updated JSON object.
 Create an invitation link with
 `client.organizations.invitations.create(workspace_id, role="member")`.
 The response includes `accept_url`. Supplying `email` also asks the platform to
-send an invitation email. Targeted customer invitations require an
-`entitlement_policy` JSON object defining the member's credit budget and rate
-limits; the SDK sends it unchanged. Omitted or `None` optional arguments are
+send an invitation email. The supported request fields are `role` and `email`.
+The SDK retains an `entitlement_policy` parameter, but the platform ignores it;
+it does not set a recipient credit budget or rate limit. Omitted or `None` optional arguments are
 left out of the request. Inspect `delivery_warning`: creation can succeed even
 if email delivery fails.
 
@@ -79,21 +82,25 @@ asyncio.run(main())
 
 ### Server prerequisites
 
-- Customer routes accept an active customer's Avartha API key. Workspace
-  membership and roles determine access; a key's workspace binding is used for
-  inference routing and does not replace management authorization.
+- A key acts only in the workspace it is bound to. Workspace administration
+  also needs the **Workspace** management access (`workspace`) and the required
+  role. A default inference key does not have that access. Listing workspaces
+  returns only the key's bound workspace.
+- `organizations.create()` needs `workspace` access. The returned workspace is
+  new; the key remains bound to the original workspace. Create a key for the new
+  workspace in the console before managing it with another client.
 - Owners and admins can rename workspaces and manage members/invitations.
   Only owners can delete a workspace or change owner access. Admins cannot
   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.
-- Targeted customer invitations require a workspace member-allocation policy
-  and a valid member entitlement policy. Email delivery requires server email
-  configuration.
-- Manage API keys through the customer portal. Creating, listing, and revoking
-  keys requires an interactive browser session and is not available through
-  this bearer-key client.
+- Email delivery requires server email configuration. Inspect any
+  `delivery_warning` even after an invitation is created.
+- API-key administration has no convenience resource in `Control`. Its verified
+  `auth/api-keys` routes accept a key with **Keys** management access (`keys`),
+  bound to the workspace, whose creator is still an Owner or Admin. The console
+  also provides these operations. Existing key secrets cannot be retrieved.
 
 ## Voice agents
 
@@ -154,7 +161,6 @@ with Control() as client:
 | `create(workspace_id, name=..., template_id=..., config=..., description=..., use_case=..., color=...)` | The new draft |
 | `update(workspace_id, agent_id, expected_generation=..., name=..., description=..., template_id=..., use_case=..., config=..., color=...)` | The saved draft |
 | `publish(workspace_id, agent_id, expected_agent_generation=..., expected_publication_generation=...)` | `action`, `publication_generation`, and `publication` |
-
 | `delete(workspace_id, agent_id, expected_generation=...)` | Nothing; the agent is gone |
 | `publications.list(workspace_id, agent_id, before=..., limit=...)` | `publications`, newest first, and `next_before` |
 | `publications.get(workspace_id, agent_id, publication_id)` | One revision with its name and `config` |
@@ -241,7 +247,6 @@ client.voice_agents.publish(
 | 409, `body["code"] == "voice_agent_capacity_exceeded"` | The workspace is at its published-agent limit | See the prerequisites below |
 | 429, `body["code"] == "rate_limit_exceeded"` | Too many management requests for this user or workspace | Wait `retry_after` seconds, then retry |
 | 403 | The key lacks the access below | Check its scope, workspace, and creator's role |
-| 404 `Voice agents aren't available for this workspace` | The feature is off for the workspace | Ask Avartha to enable it |
 | 422 with a text `body` | A required key is missing or a value has the wrong type | Correct the request as `body` describes |
 | 503 `No voice environment serves this caller...` | The platform has no voice environment for this caller, so drafts can't be saved | Contact Avartha |
 
@@ -249,9 +254,9 @@ client.voice_agents.publish(
 before trying again, because the draft may have been saved.
 
 Unpublishing, test calls, changing data retention, and creating or revoking
-credentials aren't available to API keys, so use the console for them. Tools and
-knowledge sources can be referenced in `config` once they
-exist in the workspace, but are managed elsewhere. Publishing makes an agent available,
+voice-provider credentials aren't available to API keys, so use the console for them. Tools can be
+referenced in `config` once they exist in the workspace, but are managed elsewhere.
+Publishing makes an agent available,
 and the workspace's voice-call policy still decides whether calls are admitted. To talk
 to a published agent, see [voice conversations](voice-conversations.md).
 
@@ -265,8 +270,8 @@ to a published agent, see [voice conversations](voice-conversations.md).
   name and configuration. It gets HTTP 403 for every write, for revision history, and
   for credentials. `runtime_defaults()` and `data_retention()` need only workspace
   membership.
-- The workspace needs the voice agents feature; `organizations.get(id)` lists it in
-  `feature_flags`. Saving drafts needs no other allowance.
+- Voice agents are available to every workspace; saving drafts needs no other
+  allowance.
 - Publishing a new agent needs capacity: `organizations.limits(id)` reports
   `max_voice_agents` under `limits`, and new workspaces start at zero.
 

{avartha_python_sdk-0.0.7 → avartha_python_sdk-0.0.8}/docs/pypi.md

@@ -2,11 +2,12 @@
 
 Synchronous and asynchronous Python clients for Avartha Realtime text,
 streaming speech, and platform management. Requires Python 3.12+.
+The guides and examples below use SDK 0.0.7 or later.
 
 ## Install
 
 ```sh
-python -m pip install avartha-python-sdk
+python -m pip install --upgrade 'avartha-python-sdk>=0.0.7'
 ```
 
 Configure your Avartha API key and platform root:
@@ -24,15 +25,18 @@ to your workspace. Unsupported tier values and dedicated inference URLs raise
 ## Discover models
 
 ```python
-from avartha import OpenAI
+from avartha import Avartha
 
-with OpenAI() as client:
+with Avartha() as client:
     for model in client.models.list():
         print(model.id, model.to_dict().get("protocols", []))
+    for model in client.elevenlabs.models.list():
+        print(model.model_id, getattr(model, "protocols", []))
 ```
 
-Choose a model supporting `openai_realtime` for text, `elevenlabs_tts` for
-speech synthesis, or `elevenlabs_asr` for speech recognition.
+`client.models` lists Voice LLMs; choose `openai_realtime` for text.
+`client.elevenlabs.models` lists speech models; choose `elevenlabs_tts` for
+speech synthesis or `elevenlabs_asr` for speech recognition.
 
 ## Generate text
 
@@ -80,11 +84,10 @@ Inference consumes credits.
 | Workspaces, members, invitations | `Control` / `AsyncControl` |
 | Voice agents: create, edit, publish, restore, delete | `Control` / `AsyncControl`: `voice_agents` |
 | Live conversations with published agents | `avartha.conversational_ai`: `Conversation`, `AsyncConversation` |
-| Placing phone calls from Twilio numbers | `ElevenLabs` / `AsyncElevenLabs`: `conversational_ai.twilio.outbound_call` |
 | Combined inference and management | `Avartha` / `AsyncAvartha` |
 
-Managed inference uses WebSockets; Chat Completions, Responses, HTTP TTS,
-and file transcription are unavailable. ElevenLabs-schema agent management is not
+This SDK provides model inference over WebSockets; it does not wrap HTTP
+Chat Completions, Responses, speech synthesis, or file transcription. ElevenLabs-schema agent management is not
 implemented, and accessing it under `conversational_ai` raises `NotImplementedError`.
 
 ## Migrating and handling errors
@@ -109,4 +112,4 @@ never retried automatically.
 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.
+and platform-management guides and run the text, speech, and voice-agent examples.