avartha-python-sdk 0.0.7__py3-none-any.whl → 0.0.8__py3-none-any.whl

avartha/_conversation_resources.py

@@ -8,7 +8,6 @@ import json
 from collections.abc import Mapping
 from typing import Any, Never
 
-from ._exceptions import UnsupportedOperationError
 from ._speech_config import RequestOptions
 from ._speech_http import (
     AsyncHttpResponse,
@@ -18,21 +17,13 @@ from ._speech_http import (
     segment,
 )
 from .types.conversational_ai import (
-    ConversationInitiationClientDataRequestInput,
     ConversationSignedUrlResponseModel,
     GetConversationResponseModel,
     GetConversationsPageResponseModel,
-    TelephonyCallConfigInput,
     TokenResponseModel,
-    TwilioOutboundCallResponse,
 )
 
 _BASE = "v1/convai"
-_OUTBOUND_CALL = f"{_BASE}/twilio/outbound-call"
-_IDEMPOTENCY_HEADER = "Idempotency-Key"
-# A 409 is left to the caller: the key was reused for a different call, or the workspace is at
-# its call limit, and ringing someone moments later wouldn't be expected.
-_DIAL_RETRY_STATUSES = (408, 429)
 
 
 def _encoded(value: Mapping[str, Any] | None) -> str | None:
@@ -53,50 +44,6 @@ def _mint_params(
     }
 
 
-def _dial_body(
-    agent_id: str,
-    agent_phone_number_id: str,
-    to_number: str,
-    conversation_initiation_client_data: ConversationInitiationClientDataRequestInput | None,
-    call_recording_enabled: bool | None,
-    telephony_call_config: TelephonyCallConfigInput | None,
-) -> dict[str, Any]:
-    optional = {
-        "conversation_initiation_client_data": conversation_initiation_client_data,
-        "call_recording_enabled": call_recording_enabled,
-        "telephony_call_config": telephony_call_config,
-    }
-    return {
-        "agent_id": agent_id,
-        "agent_phone_number_id": agent_phone_number_id,
-        "to_number": to_number,
-        **{name: value for name, value in optional.items() if value is not None},
-    }
-
-
-def _dial_options(
-    idempotency_key: str | None, request_options: RequestOptions | None
-) -> RequestOptions:
-    """Attach the key, and never retry without one: each keyless request rings someone."""
-    options: RequestOptions = {**(request_options or {})}
-    headers = dict(options.get("additional_headers") or {})
-    key_header = _IDEMPOTENCY_HEADER.lower()
-    if idempotency_key is not None:
-        headers = {name: value for name, value in headers.items() if name.lower() != key_header}
-        headers[_IDEMPOTENCY_HEADER] = idempotency_key
-    options["additional_headers"] = headers
-    if not any(name.lower() == key_header and value is not None for name, value in headers.items()):
-        options["max_retries"] = 0
-    return options
-
-
-def _refuse_register_call() -> Never:
-    raise UnsupportedOperationError(
-        "conversational_ai.twilio.register_call is not supported. Avartha answers calls to a "
-        "connected number with the agent assigned to it, and outbound_call places calls."
-    )
-
-
 class RawConversations:
     def __init__(self, client: SpeechHTTPClient) -> None:
         self._client = client
@@ -380,165 +327,20 @@ class AsyncConversations:
         return response.data
 
 
-class RawTwilio:
-    def __init__(self, client: SpeechHTTPClient) -> None:
-        self._client = client
-
-    def outbound_call(
-        self,
-        *,
-        agent_id: str,
-        agent_phone_number_id: str,
-        to_number: str,
-        conversation_initiation_client_data: ConversationInitiationClientDataRequestInput
-        | None = None,
-        call_recording_enabled: bool | None = None,
-        telephony_call_config: TelephonyCallConfigInput | None = None,
-        idempotency_key: str | None = None,
-        request_options: RequestOptions | None = None,
-    ) -> HttpResponse[TwilioOutboundCallResponse]:
-        return self._client.post(
-            _OUTBOUND_CALL,
-            TwilioOutboundCallResponse,
-            params={},
-            body=_dial_body(
-                agent_id,
-                agent_phone_number_id,
-                to_number,
-                conversation_initiation_client_data,
-                call_recording_enabled,
-                telephony_call_config,
-            ),
-            retry_statuses=_DIAL_RETRY_STATUSES,
-            request_options=_dial_options(idempotency_key, request_options),
-        )
-
-
-class Twilio:
-    """Place phone calls from one of the workspace's Twilio numbers."""
-
-    def __init__(self, client: SpeechHTTPClient) -> None:
-        self.with_raw_response = RawTwilio(client)
-
-    def outbound_call(
-        self,
-        *,
-        agent_id: str,
-        agent_phone_number_id: str,
-        to_number: str,
-        conversation_initiation_client_data: ConversationInitiationClientDataRequestInput
-        | None = None,
-        call_recording_enabled: bool | None = None,
-        telephony_call_config: TelephonyCallConfigInput | None = None,
-        idempotency_key: str | None = None,
-        request_options: RequestOptions | None = None,
-    ) -> TwilioOutboundCallResponse:
-        """Ring to_number and connect the agent when someone answers.
-
-        Pass idempotency_key, an Avartha extension, so a repeated request returns the first
-        attempt instead of ringing again; only then does the SDK retry. Check success: False
-        means Twilio refused the call or didn't confirm it, and an unconfirmed call may still
-        ring.
-        """
-        return self.with_raw_response.outbound_call(
-            agent_id=agent_id,
-            agent_phone_number_id=agent_phone_number_id,
-            to_number=to_number,
-            conversation_initiation_client_data=conversation_initiation_client_data,
-            call_recording_enabled=call_recording_enabled,
-            telephony_call_config=telephony_call_config,
-            idempotency_key=idempotency_key,
-            request_options=request_options,
-        ).data
-
-    def register_call(self, **kwargs: Any) -> Never:
-        _refuse_register_call()
-
-
-class AsyncRawTwilio:
-    def __init__(self, client: AsyncSpeechHTTPClient) -> None:
-        self._client = client
-
-    async def outbound_call(
-        self,
-        *,
-        agent_id: str,
-        agent_phone_number_id: str,
-        to_number: str,
-        conversation_initiation_client_data: ConversationInitiationClientDataRequestInput
-        | None = None,
-        call_recording_enabled: bool | None = None,
-        telephony_call_config: TelephonyCallConfigInput | None = None,
-        idempotency_key: str | None = None,
-        request_options: RequestOptions | None = None,
-    ) -> AsyncHttpResponse[TwilioOutboundCallResponse]:
-        return await self._client.post(
-            _OUTBOUND_CALL,
-            TwilioOutboundCallResponse,
-            params={},
-            body=_dial_body(
-                agent_id,
-                agent_phone_number_id,
-                to_number,
-                conversation_initiation_client_data,
-                call_recording_enabled,
-                telephony_call_config,
-            ),
-            retry_statuses=_DIAL_RETRY_STATUSES,
-            request_options=_dial_options(idempotency_key, request_options),
-        )
-
-
-class AsyncTwilio:
-    """Place phone calls from one of the workspace's Twilio numbers."""
-
-    def __init__(self, client: AsyncSpeechHTTPClient) -> None:
-        self.with_raw_response = AsyncRawTwilio(client)
-
-    async def outbound_call(
-        self,
-        *,
-        agent_id: str,
-        agent_phone_number_id: str,
-        to_number: str,
-        conversation_initiation_client_data: ConversationInitiationClientDataRequestInput
-        | None = None,
-        call_recording_enabled: bool | None = None,
-        telephony_call_config: TelephonyCallConfigInput | None = None,
-        idempotency_key: str | None = None,
-        request_options: RequestOptions | None = None,
-    ) -> TwilioOutboundCallResponse:
-        """Ring to_number and connect the agent when someone answers.
-
-        Pass idempotency_key, an Avartha extension, so a repeated request returns the first
-        attempt instead of ringing again; only then does the SDK retry. Check success: False
-        means Twilio refused the call or didn't confirm it, and an unconfirmed call may still
-        ring.
-        """
-        response = await self.with_raw_response.outbound_call(
-            agent_id=agent_id,
-            agent_phone_number_id=agent_phone_number_id,
-            to_number=to_number,
-            conversation_initiation_client_data=conversation_initiation_client_data,
-            call_recording_enabled=call_recording_enabled,
-            telephony_call_config=telephony_call_config,
-            idempotency_key=idempotency_key,
-            request_options=request_options,
-        )
-        return response.data
-
-    def register_call(self, **kwargs: Any) -> Never:
-        _refuse_register_call()
-
-
 class _ConversationalAi:
     def __getattr__(self, name: str) -> Never:
         if name.startswith("_"):
             raise AttributeError(name)
+        if name == "twilio":
+            # Phone calls need workspace features that aren't available to every workspace.
+            raise NotImplementedError(
+                "conversational_ai.twilio is not available in this SDK. "
+                "conversational_ai.conversations is available."
+            )
         raise NotImplementedError(
             f"conversational_ai.{name} is not implemented. ElevenLabs-schema agents, tools, and "
             "knowledge bases will be implemented in a future release; "
-            "conversational_ai.conversations and conversational_ai.twilio are available, "
+            "conversational_ai.conversations is available, "
             "and Control.voice_agents manages Avartha voice agents."
         )
 
@@ -546,10 +348,8 @@ class _ConversationalAi:
 class ConversationalAi(_ConversationalAi):
     def __init__(self, client: SpeechHTTPClient) -> None:
         self.conversations = Conversations(client)
-        self.twilio = Twilio(client)
 
 
 class AsyncConversationalAi(_ConversationalAi):
     def __init__(self, client: AsyncSpeechHTTPClient) -> None:
         self.conversations = AsyncConversations(client)
-        self.twilio = AsyncTwilio(client)

avartha/_realtime_tts.py

@@ -8,6 +8,8 @@ text fragments unchanged, preserve errors, and use owned multi-context message t
 import asyncio
 import base64
 import json
+import logging
+import time
 from collections.abc import (
     AsyncGenerator,
     AsyncIterable,
@@ -53,6 +55,8 @@ from .types.speech import (
     VoiceSettings,
 )
 
+log = logging.getLogger(__name__)
+
 ReceiveMessageMulti = AudioOutputMulti | FinalOutputMulti
 SendMessageMulti = (
     InitializeConnectionMulti | SendTextMulti | FlushContext | CloseContext | CloseSocket
@@ -106,38 +110,57 @@ def _query(
     *,
     request_options: RequestOptions | None = None,
 ) -> dict[str, Any]:
-    """The connection query; refuses option values the runtime always rejects."""
-    output_format = output_format or DEFAULT_OUTPUT_FORMAT
-    query: dict[str, Any] = {
-        "model_id": model_id,
-        "output_format": output_format,
-        "auto_mode": "true",
-    }
-    if inactivity_timeout is not None:
-        if (
-            isinstance(inactivity_timeout, bool)
-            or not isinstance(inactivity_timeout, int)
-            or inactivity_timeout not in _INACTIVITY_TIMEOUT_SECONDS
-        ):
-            raise ValueError("inactivity_timeout must be a whole number of seconds from 1 to 180")
-        query["inactivity_timeout"] = inactivity_timeout
-    if sync_alignment is not None:
-        if not isinstance(sync_alignment, bool):
-            raise ValueError("sync_alignment must be True or False")
-        if sync_alignment and output_format.startswith("mp3_"):
-            raise ValueError(
-                "sync_alignment=True requires PCM or G.711 output; "
-                "MP3 packets do not share the alignment clock"
-            )
-        query["sync_alignment"] = str(sync_alignment).lower()
-    # Match HTTP request_options precedence: explicit extra query values override
-    # defaults and named arguments, while None omits a parameter.
+    """The connection query; refuses option values the runtime always rejects.
+
+    Extra query values in `request_options` override defaults and named arguments,
+    as for HTTP requests, and None omits a parameter. Named arguments are checked
+    as given, then the merged values are checked again, so an override cannot send
+    a value the runtime refuses.
+    """
+    if inactivity_timeout is not None and not _valid_inactivity_timeout(inactivity_timeout):
+        raise ValueError(_INACTIVITY_TIMEOUT_ERROR)
+    if sync_alignment is not None and not isinstance(sync_alignment, bool):
+        raise ValueError("sync_alignment must be True or False")
     extra = request_options.get("additional_query_parameters", {}) if request_options else {}
-    query = remove_none_from_dict({**query, **extra})
-    return {
+    merged = remove_none_from_dict(
+        {
+            "model_id": model_id,
+            "output_format": output_format or DEFAULT_OUTPUT_FORMAT,
+            "auto_mode": "true",
+            "inactivity_timeout": inactivity_timeout,
+            "sync_alignment": sync_alignment,
+            **extra,
+        }
+    )
+    query = {
         key: str(value).lower() if isinstance(value, bool) else value
-        for key, value in query.items()
+        for key, value in merged.items()
     }
+    if "inactivity_timeout" in query and not _valid_inactivity_timeout(query["inactivity_timeout"]):
+        raise ValueError(_INACTIVITY_TIMEOUT_ERROR)
+    alignment = query.get("sync_alignment")
+    if alignment is not None and alignment not in ("true", "false"):
+        raise ValueError("sync_alignment must be True or False")
+    if alignment == "true" and str(query.get("output_format", "")).startswith("mp3_"):
+        raise ValueError(
+            "sync_alignment=True requires PCM or G.711 output; "
+            "MP3 packets do not share the alignment clock"
+        )
+    return query
+
+
+_INACTIVITY_TIMEOUT_ERROR = "inactivity_timeout must be a whole number of seconds from 1 to 180"
+
+
+def _valid_inactivity_timeout(value: Any) -> bool:
+    """An int, or the runtime's digits-only query spelling, from 1 to 180."""
+    if isinstance(value, str) and value.isascii() and value.isdigit():
+        value = int(value)
+    return (
+        isinstance(value, int)
+        and not isinstance(value, bool)
+        and value in _INACTIVITY_TIMEOUT_SECONDS
+    )
 
 
 def _headers(base: Mapping[str, str], request_options: RequestOptions | None) -> dict[str, str]:
@@ -158,6 +181,25 @@ def _audio(payload: Any) -> bytes | None:
     return base64.b64decode(encoded) if encoded else None
 
 
+def _warning(payload: Any) -> bool:
+    """Log a runtime warning; True when the frame carries nothing else to deliver.
+
+    The runtime sends one, for example, when voice_settings it accepts for
+    compatibility have no effect. A warning never fails the utterance.
+    """
+    if not isinstance(payload, Mapping) or not isinstance(payload.get("warning"), str):
+        return False
+    context_id = payload.get("contextId") or payload.get("context_id")
+    where = f" for context {context_id!r}" if isinstance(context_id, str) else ""
+    log.warning("Text-to-speech warning%s: %s", where, payload["warning"])
+    return not (
+        payload.get("audio")
+        or payload.get("isFinal")
+        or payload.get("is_final")
+        or payload.get("error") is not None
+    )
+
+
 def _raise_stream_error(payload: Any) -> None:
     """A failed utterance is terminal even if the socket remains open."""
     if isinstance(payload, Mapping) and payload.get("error") is not None:
@@ -275,8 +317,10 @@ class AvarthaRealtimeTextToSpeechClient:
 
         `output_format` defaults to `DEFAULT_OUTPUT_FORMAT`; see
         `TextToSpeechOutputFormat` for PCM, MP3 and G.711 delivery formats.
-        `voice_settings` is forwarded when supplied, but the gateway rejects any
-        non-null value; leave it unset unless the platform has gained support for it.
+        `voice_settings` is forwarded when supplied. Valid `stability`,
+        `similarity_boost`, `style` and `use_speaker_boost` values are accepted for
+        compatibility but do not change synthesis; the runtime's warning is logged.
+        `speed` must be omitted or 1.0.
 
         `inactivity_timeout` is an Avartha extension: the seconds (1 to 180) the
         runtime waits for more text before ending the utterance; omission uses
@@ -338,6 +382,7 @@ class AvarthaRealtimeTextToSpeechClient:
                 while True:
                     received = json.loads(socket.recv())
                     _raise_stream_error(received)
+                    _warning(received)
                     if audio := _audio(received):
                         yield audio
             except websockets.exceptions.ConnectionClosed as closed:
@@ -481,6 +526,7 @@ class AvarthaAsyncRealtimeTextToSpeechClient:
                             raise error
                     received = json.loads(await receiver)
                     _raise_stream_error(received)
+                    _warning(received)
                     if audio := _audio(received):
                         yield audio
             except websockets.exceptions.ConnectionClosed as closed:
@@ -633,7 +679,10 @@ class _MultiContextProtocol:
     def close_socket(self) -> dict[str, Any]:
         return _frame(CloseSocket(close_socket=True))
 
-    def receive(self, payload: Mapping[str, Any]) -> ReceiveMessageMulti:
+    def receive(self, payload: Mapping[str, Any]) -> ReceiveMessageMulti | None:
+        """The typed message, or None for a warning that carries nothing else."""
+        if _warning(payload):
+            return None
         context_id = payload.get("contextId") or payload.get("context_id")
         context = self._contexts.get(context_id) if isinstance(context_id, str) else None
         if payload.get("error") is not None or ("code" in payload and "message" in payload):
@@ -719,9 +768,15 @@ class MultiContextSession:
         """Return the next message, or None after a complete, cleanly closed stream.
 
         Raises `ApiError` for gateway errors or closure before all finals arrive.
+        Runtime warnings are logged and skipped; `timeout` covers the whole wait.
         """
+        deadline = None if timeout is None else time.monotonic() + timeout
         try:
-            return self._protocol.receive(json.loads(self._socket.recv(timeout)))
+            while True:
+                remaining = None if deadline is None else max(0.0, deadline - time.monotonic())
+                message = self._protocol.receive(json.loads(self._socket.recv(remaining)))
+                if message is not None:
+                    return message
         except websockets.exceptions.ConnectionClosed as closed:
             if closed.code == 1000 and not self._protocol.draining:
                 return None
@@ -897,14 +952,17 @@ class AsyncMultiContextSession:
                 raise
 
     async def receive(self, timeout: float | None = None) -> ReceiveMessageMulti | None:
-        """Return the next message, or None after a complete, cleanly closed stream."""
+        """Return the next message, or None after a complete, cleanly closed stream.
+
+        Runtime warnings are logged and skipped; `timeout` covers the whole wait.
+        """
         self._check_send_failure()
         try:
-            if timeout is None:
-                payload = await self._socket.recv()
-            else:
-                payload = await asyncio.wait_for(self._socket.recv(), timeout)
-            return self._protocol.receive(json.loads(payload))
+            async with asyncio.timeout(timeout):
+                while True:
+                    message = self._protocol.receive(json.loads(await self._socket.recv()))
+                    if message is not None:
+                        return message
         except websockets.exceptions.ConnectionClosed as closed:
             if closed.code == 1000 and not self._protocol.draining:
                 return None

avartha/_speech_http.py

@@ -64,9 +64,6 @@ class AsyncHttpResponse[T]:
         return AsyncHttpResponse(self._response, transform(self.data))
 
 
-_RETRY_STATUSES = (408, 409, 429)
-
-
 def segment(value: str) -> str:
     if value in {".", ".."}:
         raise ValueError("Resource identifiers cannot be path traversal segments")
@@ -157,19 +154,17 @@ class _Settings:
         path: str,
         params: Mapping[str, Any],
         options: RequestOptions,
-        body: Mapping[str, Any] | None = None,
     ) -> httpx.Request:
         url = not_vendor_host(f"{self.base_url.rstrip('/')}/{path}", field="base_url")
         query = {**params, **(options.get("additional_query_parameters") or {})}
         headers = {**self.headers, **(options.get("additional_headers") or {})}
-        content = {**(body or {}), **(options.get("additional_body_parameters") or {})}
         timeout = options.get("timeout_in_seconds")
         return client.build_request(
             method,
             url,
             params=_query(jsonable_encoder(query)) or None,
             headers={key: value for key, value in headers.items() if value is not None},
-            json=jsonable_encoder(content) or None,
+            json=jsonable_encoder(options.get("additional_body_parameters")) or None,
             timeout=self.timeout if timeout is None else timeout,
         )
 
@@ -207,12 +202,10 @@ class SpeechHTTPClient:
         schema: type[T],
         *,
         params: Mapping[str, Any],
-        body: Mapping[str, Any] | None = None,
-        retry_statuses: tuple[int, ...] = _RETRY_STATUSES,
         request_options: RequestOptions | None = None,
     ) -> HttpResponse[T]:
-        """Send a POST; retried like GET unless request_options sets max_retries to 0."""
-        return self._send("POST", path, schema, params, request_options, body, retry_statuses)
+        """Send a body-less POST; retried like GET, so use it only for idempotent routes."""
+        return self._send("POST", path, schema, params, request_options)
 
     def _send[T](
         self,
@@ -221,8 +214,6 @@ class SpeechHTTPClient:
         schema: type[T],
         params: Mapping[str, Any],
         request_options: RequestOptions | None,
-        body: Mapping[str, Any] | None = None,
-        retry_statuses: tuple[int, ...] = _RETRY_STATUSES,
     ) -> HttpResponse[T]:
         if self._closed:
             raise RuntimeError("Cannot send a request, as the client has been closed.")
@@ -230,7 +221,7 @@ class SpeechHTTPClient:
             self._client = httpx.Client()
         options = request_options or {}
         for attempt in range(max(0, options.get("max_retries", 2)) + 1):
-            request = self._settings.request(self._client, method, path, params, options, body)
+            request = self._settings.request(self._client, method, path, params, options)
             with wrap_httpx_errors():
                 for redirects in range(self._client.max_redirects + 1):
                     response = self._client.send(request, follow_redirects=False)
@@ -246,7 +237,7 @@ class SpeechHTTPClient:
                     finally:
                         response.close()
             if (
-                response.status_code >= 500 or response.status_code in retry_statuses
+                response.status_code >= 500 or response.status_code in (408, 409, 429)
             ) and attempt < options.get("max_retries", 2):
                 delay = _retry_delay(response, attempt)
                 response.close()
@@ -298,12 +289,10 @@ class AsyncSpeechHTTPClient:
         schema: type[T],
         *,
         params: Mapping[str, Any],
-        body: Mapping[str, Any] | None = None,
-        retry_statuses: tuple[int, ...] = _RETRY_STATUSES,
         request_options: RequestOptions | None = None,
     ) -> AsyncHttpResponse[T]:
-        """Send a POST; retried like GET unless request_options sets max_retries to 0."""
-        return await self._send("POST", path, schema, params, request_options, body, retry_statuses)
+        """Send a body-less POST; retried like GET, so use it only for idempotent routes."""
+        return await self._send("POST", path, schema, params, request_options)
 
     async def _send[T](
         self,
@@ -312,8 +301,6 @@ class AsyncSpeechHTTPClient:
         schema: type[T],
         params: Mapping[str, Any],
         request_options: RequestOptions | None,
-        body: Mapping[str, Any] | None = None,
-        retry_statuses: tuple[int, ...] = _RETRY_STATUSES,
     ) -> AsyncHttpResponse[T]:
         if self._closed:
             raise RuntimeError("Cannot send a request, as the client has been closed.")
@@ -321,7 +308,7 @@ class AsyncSpeechHTTPClient:
             self._client = httpx.AsyncClient()
         options = request_options or {}
         for attempt in range(max(0, options.get("max_retries", 2)) + 1):
-            request = self._settings.request(self._client, method, path, params, options, body)
+            request = self._settings.request(self._client, method, path, params, options)
             with wrap_httpx_errors():
                 for redirects in range(self._client.max_redirects + 1):
                     response = await self._client.send(request, follow_redirects=False)
@@ -337,7 +324,7 @@ class AsyncSpeechHTTPClient:
                     finally:
                         await response.aclose()
             if (
-                response.status_code >= 500 or response.status_code in retry_statuses
+                response.status_code >= 500 or response.status_code in (408, 409, 429)
             ) and attempt < options.get("max_retries", 2):
                 delay = _retry_delay(response, attempt)
                 await response.aclose()

avartha/types/conversational_ai.py

@@ -1,7 +1,6 @@
-"""Avartha's conversation route types; unlisted server response fields stay available."""
+"""Responses from Avartha's conversation routes; unlisted server fields stay available."""
 
 import typing
-from collections.abc import Mapping
 
 import pydantic
 
@@ -51,27 +50,3 @@ class GetConversationResponseModel(ConversationSummaryResponseModel):
     has_audio: bool | None = pydantic.Field(default=None)
     has_user_audio: bool | None = pydantic.Field(default=None)
     has_response_audio: bool | None = pydantic.Field(default=None)
-
-
-class ConversationInitiationClientDataRequestInput(typing.TypedDict, total=False):
-    """What a placed call accepts of the ElevenLabs model of this name."""
-
-    dynamic_variables: Mapping[str, typing.Any] | None
-
-
-class TelephonyCallConfigInput(typing.TypedDict, total=False):
-    """What a placed call accepts of the ElevenLabs model of this name.
-
-    The platform refuses `True` for recording and any object for machine detection.
-    """
-
-    ringing_timeout_secs: int | None
-    twilio_call_recording_enabled: bool | None
-    twilio_machine_detection: Mapping[str, typing.Any] | None
-
-
-class TwilioOutboundCallResponse(_Response):
-    success: bool = pydantic.Field()
-    message: str = pydantic.Field()
-    conversation_id: str | None = pydantic.Field(default=None)
-    call_sid: str | None = pydantic.Field(default=None, alias="callSid")

avartha/types/voice_agents.py

@@ -85,11 +85,6 @@ class VoiceAgentToolBinding(TypedDict):
     tool_settings: NotRequired[dict[str, VoiceToolSettings]]
 
 
-class VoiceAgentKnowledgeBinding(TypedDict):
-    kind: Literal["document", "folder"]
-    id: str
-
-
 class VoiceAgentConfig(TypedDict):
     """Versioned agent configuration, always sent and replaced as a whole."""
 
@@ -111,7 +106,6 @@ class VoiceAgentConfig(TypedDict):
     built_in_tools: NotRequired[dict[str, VoiceAgentBuiltInTool]]
     tools: NotRequired[list[str]]
     tool_bindings: NotRequired[list[VoiceAgentToolBinding]]
-    knowledge_bindings: NotRequired[list[VoiceAgentKnowledgeBinding]]
     capabilities: NotRequired[list[str]]
     chat_artifacts_enabled: NotRequired[bool]
 

{avartha_python_sdk-0.0.7.dist-info → avartha_python_sdk-0.0.8.dist-info}/METADATA

@@ -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.dist-info → avartha_python_sdk-0.0.8.dist-info}/RECORD

@@ -1,6 +1,6 @@
 avartha/__init__.py,sha256=Myea2lrcfw5ZmPj1ZbKOhKdi5CQY44VEKoFTCy8uqyQ,2900
 avartha/_config.py,sha256=mzaHiqYH_7N4okLijiRbJlCNyxvZn4Ni_A_OAZDtOTA,6314
-avartha/_conversation_resources.py,sha256=uLnnuCF_wtd09mNHtk0kwQKv2Oe8kGSEmrUWyNc47Gw,20832
+avartha/_conversation_resources.py,sha256=DmMKUNBh6NPZWFGpm734tzE9HecCWsEFBa30CXTXbOM,13134
 avartha/_exceptions.py,sha256=_QY7SEw2nqyOz3pNxDWi40GW1xqB3EZxJ0t4iJ-YBpQ,1588
 avartha/_http_errors.py,sha256=gU8eapqYcI7Q3M8lAxwVH-qwz-TnQf2loBThFKG0ka8,406
 avartha/_models.py,sha256=KB4PeFvktbSOKbT-qMX5tjsExEg9cwufZ3ourx8GcVI,7331
@@ -11,10 +11,10 @@ avartha/_realtime_asr.py,sha256=KIonb9PUdkKnsP_nQKJOrcsLgjIh9jUnV_ngXFWsWzM,1819
 avartha/_realtime_openai.py,sha256=kqdn6K1IMQFUgu_RQXhQxmkWnq2BxVUbicF4_2vhp4o,23859
 avartha/_realtime_resources.py,sha256=rZj8hBYuLP9kTX56hhXTGE8R3crW_Wfmn46VY_dL3TM,7489
 avartha/_realtime_sampling.py,sha256=m4-aPCcvxCxA2l61cRCD2IRAbtKASMSadJVmHu8WkoU,3238
-avartha/_realtime_tts.py,sha256=jMK_uRUNY4yuWfaem_tdLp_J8ZgQEBNzvzVlzGDN-xY,38521
+avartha/_realtime_tts.py,sha256=gxL0mPlTnQ_J9zPinfRDXA1T-XQbBJcUa-iKW-QwlSg,40869
 avartha/_sentinels.py,sha256=eX9pg8L8DMWOLrNLfJKWjcFHC5GZO0I_snULCum0ehg,433
 avartha/_speech_config.py,sha256=jL0M8Z6MGXzfgf3Lm7QMMEKDtVXCW5-jrqz5WEtu9g4,1781
-avartha/_speech_http.py,sha256=1oenxxk5Qvj6JqkVgl11sDeogTBp1af-Kxp2nAnKRJg,12917
+avartha/_speech_http.py,sha256=86HO-ocVdGILaPRxLFi5LTzCqleFxwCWJHxMwePYLsE,12308
 avartha/_speech_resources.py,sha256=zBJHkQkllmWG_bmTIhwmjz9Nf7w4JMNkKJimnaIL3_4,18628
 avartha/_unsupported.py,sha256=qrbsxi2SL6co5M2uLs4fTVOoISuUm58khoayeL22gPE,637
 avartha/_websocket.py,sha256=9R05huh1n8spuyg1n_aIJN0Uk_kLG7BbNPD88wogIKY,855
@@ -35,10 +35,10 @@ avartha/resources/models.py,sha256=49IEOptS4QztywPbR0QQ0q-TvyHcKMpqklGNZ8HNXH0,6
 avartha/resources/realtime/__init__.py,sha256=-eWjNw1X8STRlDvKHgpMf4CvKiTbWgPJ6L_crxVpoTA,439
 avartha/resources/realtime/realtime.py,sha256=zqA5c_-9bzROwXFNyQe5s-tSCu8B6N-NqiimJlmpPqk,1061
 avartha/types/__init__.py,sha256=dTxUAbFhfjXbh9N2TtOSg0YeeWU5Lobf2gq1Nql9qZA,171
-avartha/types/conversational_ai.py,sha256=WxmUaCtaSfkeym6tNhG_JllKvT_-VnAvfy_kNcp6-QM,2919
+avartha/types/conversational_ai.py,sha256=v67gXcim9jzeT2bSdgV_9bWAIXHH5F8safyMTBcj5-8,2035
 avartha/types/model.py,sha256=1bDAGerzYfk0I94TbDJriq3Z-l6W7OAqdVj2obq-ZZc,261
 avartha/types/speech_language.py,sha256=PT0uG-fwX2dGHwc1xcoM1VSMaNkOILS1AKcSXX8eyd0,388
-avartha/types/voice_agents.py,sha256=WokYiN38F-VuBkiyFHjblahz8reHwMuSY3zEhSzr6zs,5922
+avartha/types/voice_agents.py,sha256=GLoJW1dt-fZ328QPsfRgf59oEFUoslmTcQqciJZHASk,5753
 avartha/types/websocket_connection_options.py,sha256=EuXoeyPKU4EMHqViOIzYZzvprE9FPPgGrUhHb_2Fcrg,816
 avartha/types/websocket_reconnection.py,sha256=sQ9X1jp31R2Ut5YdUHAtxMORw8KV-XKsPoczmGaNU6Q,580
 avartha/types/audio/__init__.py,sha256=dnsktnAoypmB2Zr3tll_k6q4M7_3scl-HdyJwfTsA0A,119
@@ -253,9 +253,9 @@ avartha/types/speech/voice_sharing_response.py,sha256=KRO9Rq80wTYV5of2bRrFTVJSDf
 avartha/types/speech/voice_sharing_response_category.py,sha256=0yFm6b7R4piHdNTdBWTQYKpNPxW8r2HJvnMdVpT7s5U,241
 avartha/types/speech/voice_sharing_state.py,sha256=8EBRbrRaDhUEap39kDXmt54AYeG172fnuBmRV1TSHP4,201
 avartha/types/speech/voice_verification_response.py,sha256=IL_Z1OTIiR9mvuaWzF9-GsL7pMRZ5fJeV_W3FfjLTTY,770
-avartha_python_sdk-0.0.7.dist-info/licenses/LICENSE,sha256=1ulXrK7aq7kBXX1scK6IiOgnbwqpmK6kWIB3CYznVG8,1135
-avartha_python_sdk-0.0.7.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=R62M0553miTc6E42IVFLUIYkLFim_mf_Abq1lty0IaQ,13081
-avartha_python_sdk-0.0.7.dist-info/METADATA,sha256=wibaSI9cuzi40eo1iUSdw7okkhM6n0YFL-VKC-AMjY4,5970
-avartha_python_sdk-0.0.7.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-avartha_python_sdk-0.0.7.dist-info/top_level.txt,sha256=cj2kDXl33tO2IPWPduSTukcwozPnYKOsVUVE9QZRUr0,8
-avartha_python_sdk-0.0.7.dist-info/RECORD,,
+avartha_python_sdk-0.0.8.dist-info/licenses/LICENSE,sha256=1ulXrK7aq7kBXX1scK6IiOgnbwqpmK6kWIB3CYznVG8,1135
+avartha_python_sdk-0.0.8.dist-info/licenses/THIRD_PARTY_NOTICES,sha256=R62M0553miTc6E42IVFLUIYkLFim_mf_Abq1lty0IaQ,13081
+avartha_python_sdk-0.0.8.dist-info/METADATA,sha256=Aekvr_tp9UEQaiGEZ9woczskwXm9rw2_4Yqzddvdnf4,6138
+avartha_python_sdk-0.0.8.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+avartha_python_sdk-0.0.8.dist-info/top_level.txt,sha256=cj2kDXl33tO2IPWPduSTukcwozPnYKOsVUVE9QZRUr0,8
+avartha_python_sdk-0.0.8.dist-info/RECORD,,