signalwire-sdk 3.0.2.dev42__tar.gz → 3.0.2.dev43__tar.gz

{signalwire_sdk-3.0.2.dev42/signalwire/signalwire_sdk.egg-info → signalwire_sdk-3.0.2.dev43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire-sdk
-Version: 3.0.2.dev42
+Version: 3.0.2.dev43
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_sdk-3.0.2.dev42 → signalwire_sdk-3.0.2.dev43}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire-sdk"
-version = "3.0.2.dev42"
+version = "3.0.2.dev43"
 description = "SignalWire SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_sdk-3.0.2.dev42 → signalwire_sdk-3.0.2.dev43}/signalwire/signalwire/__init__.py

@@ -18,7 +18,7 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "3.0.2.dev42"
+__version__ = "3.0.2.dev43"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

{signalwire_sdk-3.0.2.dev42 → signalwire_sdk-3.0.2.dev43}/signalwire/signalwire/agent_server.py

@@ -61,7 +61,7 @@ class AgentServer:
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="3.0.2.dev42",
+            version="3.0.2.dev43",
             redirect_slashes=False,
             docs_url=None,
             redoc_url=None,

{signalwire_sdk-3.0.2.dev42 → signalwire_sdk-3.0.2.dev43}/signalwire/signalwire/relay/call.py

@@ -9,6 +9,10 @@ from typing import Any, Callable, Coroutine, Optional, TYPE_CHECKING
 from signalwire.core.logging_config import get_logger
 
 from .constants import (
+    CALL_STATE_CREATED,
+    CALL_STATE_RINGING,
+    CALL_STATE_ANSWERED,
+    CALL_STATE_ENDING,
     CALL_STATE_ENDED,
     EVENT_CALL_PLAY,
     EVENT_CALL_RECORD,
@@ -515,6 +519,216 @@ class Call:
         action = PlayAction(self, cid)
         return await self._start_action(action, "play", params, on_completed=on_completed)
 
+    async def play_tts(
+        self,
+        text: str,
+        *,
+        language: Optional[str] = None,
+        gender: Optional[str] = None,
+        voice: Optional[str] = None,
+        volume: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> PlayAction:
+        """Play text-to-speech. Typed convenience over :meth:`play`.
+
+        Restores the legacy ``call.play_tts(text=...)`` ergonomics so callers
+        don't hand-build the ``{"type": "tts", "params": {...}}`` media shape.
+        """
+        tts: dict[str, Any] = {"text": text}
+        if language is not None:
+            tts["language"] = language
+        if gender is not None:
+            tts["gender"] = gender
+        if voice is not None:
+            tts["voice"] = voice
+        return await self.play(
+            [{"type": "tts", "params": tts}], volume=volume, on_completed=on_completed
+        )
+
+    async def play_audio(
+        self,
+        url: str,
+        *,
+        volume: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> PlayAction:
+        """Play an audio file from a URL. Typed convenience over :meth:`play`."""
+        return await self.play(
+            [{"type": "audio", "params": {"url": url}}],
+            volume=volume,
+            on_completed=on_completed,
+        )
+
+    async def play_silence(
+        self,
+        duration: float,
+        *,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> PlayAction:
+        """Play silence for ``duration`` seconds. Typed convenience over :meth:`play`."""
+        return await self.play(
+            [{"type": "silence", "params": {"duration": duration}}],
+            on_completed=on_completed,
+        )
+
+    async def play_ringtone(
+        self,
+        name: str,
+        *,
+        duration: Optional[float] = None,
+        volume: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> PlayAction:
+        """Play a named ringtone by country code. Typed convenience over :meth:`play`."""
+        rt: dict[str, Any] = {"name": name}
+        if duration is not None:
+            rt["duration"] = duration
+        return await self.play(
+            [{"type": "ringtone", "params": rt}], volume=volume, on_completed=on_completed
+        )
+
+    # ------------------------------------------------------------------
+    # Detect convenience (typed wrappers over detect())
+    # ------------------------------------------------------------------
+
+    async def detect_digit(
+        self,
+        *,
+        digits: Optional[str] = None,
+        timeout: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> DetectAction:
+        """Detect DTMF digits. Typed convenience over :meth:`detect`."""
+        params: dict[str, Any] = {}
+        if digits is not None:
+            params["digits"] = digits
+        return await self.detect(
+            {"type": "digit", "params": params}, timeout=timeout, on_completed=on_completed
+        )
+
+    async def detect_answering_machine(
+        self,
+        *,
+        initial_timeout: Optional[float] = None,
+        end_silence_timeout: Optional[float] = None,
+        machine_voice_threshold: Optional[float] = None,
+        machine_words_threshold: Optional[int] = None,
+        detect_interruptions: Optional[bool] = None,
+        detect_message_end: Optional[bool] = None,
+        timeout: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> DetectAction:
+        """Detect human vs answering machine (AMD). Typed convenience over :meth:`detect`."""
+        params: dict[str, Any] = {}
+        for key, val in (
+            ("initial_timeout", initial_timeout),
+            ("end_silence_timeout", end_silence_timeout),
+            ("machine_voice_threshold", machine_voice_threshold),
+            ("machine_words_threshold", machine_words_threshold),
+            ("detect_interruptions", detect_interruptions),
+            ("detect_message_end", detect_message_end),
+        ):
+            if val is not None:
+                params[key] = val
+        return await self.detect(
+            {"type": "machine", "params": params}, timeout=timeout, on_completed=on_completed
+        )
+
+    async def detect_fax(
+        self,
+        *,
+        tone: Optional[str] = None,
+        timeout: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> DetectAction:
+        """Detect a fax tone (CED/CNG). Typed convenience over :meth:`detect`."""
+        params: dict[str, Any] = {}
+        if tone is not None:
+            params["tone"] = tone
+        return await self.detect(
+            {"type": "fax", "params": params}, timeout=timeout, on_completed=on_completed
+        )
+
+    # ------------------------------------------------------------------
+    # Prompt convenience (typed media over play_and_collect())
+    # ------------------------------------------------------------------
+
+    async def prompt_tts(
+        self,
+        text: str,
+        collect: dict[str, Any],
+        *,
+        language: Optional[str] = None,
+        gender: Optional[str] = None,
+        voice: Optional[str] = None,
+        volume: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> CollectAction:
+        """Play TTS then collect input. Typed media over :meth:`play_and_collect`."""
+        tts: dict[str, Any] = {"text": text}
+        if language is not None:
+            tts["language"] = language
+        if gender is not None:
+            tts["gender"] = gender
+        if voice is not None:
+            tts["voice"] = voice
+        return await self.play_and_collect(
+            [{"type": "tts", "params": tts}], collect, volume=volume, on_completed=on_completed
+        )
+
+    async def prompt_audio(
+        self,
+        url: str,
+        collect: dict[str, Any],
+        *,
+        volume: Optional[float] = None,
+        on_completed: Optional[Callable[[RelayEvent], Any]] = None,
+    ) -> CollectAction:
+        """Play an audio file then collect input. Typed media over :meth:`play_and_collect`."""
+        return await self.play_and_collect(
+            [{"type": "audio", "params": {"url": url}}],
+            collect,
+            volume=volume,
+            on_completed=on_completed,
+        )
+
+    # ------------------------------------------------------------------
+    # State-wait convenience (typed waits over wait_for())
+    # ------------------------------------------------------------------
+
+    async def _wait_for_state(self, target: str, timeout: Optional[float]) -> RelayEvent:
+        order = (
+            CALL_STATE_CREATED,
+            CALL_STATE_RINGING,
+            CALL_STATE_ANSWERED,
+            CALL_STATE_ENDING,
+            CALL_STATE_ENDED,
+        )
+
+        def rank(s: str) -> int:
+            return order.index(s) if s in order else -1
+
+        # Already at or past the target -> return immediately (matches legacy SDK).
+        if rank(self.state) >= rank(target):
+            return RelayEvent(event_type=EVENT_CALL_STATE, params={"call_state": self.state})
+        return await self.wait_for(
+            EVENT_CALL_STATE,
+            lambda e: e.params.get("call_state") == target,
+            timeout=timeout,
+        )
+
+    async def wait_for_answered(self, timeout: Optional[float] = None) -> RelayEvent:
+        """Wait until the call is answered (immediate if already answered or past it)."""
+        return await self._wait_for_state(CALL_STATE_ANSWERED, timeout)
+
+    async def wait_for_ringing(self, timeout: Optional[float] = None) -> RelayEvent:
+        """Wait until the call is ringing (immediate if already ringing or past it)."""
+        return await self._wait_for_state(CALL_STATE_RINGING, timeout)
+
+    async def wait_for_ending(self, timeout: Optional[float] = None) -> RelayEvent:
+        """Wait until the call is ending (immediate if already ending or past it)."""
+        return await self._wait_for_state(CALL_STATE_ENDING, timeout)
+
     # ------------------------------------------------------------------
     # Recording
     # ------------------------------------------------------------------

{signalwire_sdk-3.0.2.dev42 → signalwire_sdk-3.0.2.dev43/signalwire/signalwire_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire-sdk
-Version: 3.0.2.dev42
+Version: 3.0.2.dev43
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT