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

{signalwire_sdk-3.0.2.dev41/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.dev41
+Version: 3.0.2.dev43
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_sdk-3.0.2.dev41 → 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.dev41"
+version = "3.0.2.dev43"
 description = "SignalWire SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_sdk-3.0.2.dev41 → 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.dev41"
+__version__ = "3.0.2.dev43"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase
@@ -42,30 +42,14 @@ def _get_skill_registry():
     import signalwire.skills
     return signalwire.skills.skill_registry
 
-# Lazy import convenience functions from the CLI (if available)
-def start_agent(*args, **kwargs):
-    """Start an agent (lazy import)"""
-    try:
-        from signalwire.cli.helpers import start_agent as _start_agent
-        return _start_agent(*args, **kwargs)
-    except ImportError:
-        raise NotImplementedError("CLI helpers not available")
-
-def run_agent(*args, **kwargs):
-    """Run an agent (lazy import)"""
-    try:
-        from signalwire.cli.helpers import run_agent as _run_agent
-        return _run_agent(*args, **kwargs)
-    except ImportError:
-        raise NotImplementedError("CLI helpers not available")
-
-def list_skills(*args, **kwargs):
-    """List available skills (lazy import)"""
-    try:
-        from signalwire.cli.helpers import list_skills as _list_skills
-        return _list_skills(*args, **kwargs)
-    except ImportError:
-        raise NotImplementedError("CLI helpers not available")
+def list_skills():
+    """List all available skills with metadata.
+
+    Returns one dict per skill (name, description, version, required packages /
+    env vars, multi-instance support). Delegates to the skill registry — the
+    same source as ``list_skills_with_params()``, but the lighter summary."""
+    from signalwire.skills.registry import skill_registry
+    return skill_registry.list_skills()
 
 def list_skills_with_params():
     """
@@ -148,8 +132,6 @@ __all__ = [
     "Step",
     "create_simple_context",
     "WebService",
-    "start_agent",
-    "run_agent",
     "list_skills",
     "list_skills_with_params",
     "register_skill",

{signalwire_sdk-3.0.2.dev41 → 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.dev41",
+            version="3.0.2.dev43",
             redirect_slashes=False,
             docs_url=None,
             redoc_url=None,

{signalwire_sdk-3.0.2.dev41 → 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.dev41 → signalwire_sdk-3.0.2.dev43}/signalwire/signalwire/skills/registry.py

@@ -119,10 +119,13 @@ class SkillRegistry:
             self.logger.error(f"Failed to load skill '{skill_name}' from {skill_file}: {e}")
             return None
     
-    def discover_skills(self) -> None:
-        """Deprecated: Skills are now loaded on-demand"""
-        # Keep this method for backwards compatibility but make it a no-op
-        pass
+    def discover_skills(self) -> List[Dict[str, str]]:
+        """Discover and return all available skills.
+
+        Skills load on-demand, so there is nothing to eagerly register; this
+        scans the skills package and returns metadata for everything
+        discoverable, so callers can enumerate what is available."""
+        return self.list_skills()
     
     def _load_skill_from_directory(self, skill_dir: Path) -> None:
         """Deprecated: Skills are now loaded on-demand"""

{signalwire_sdk-3.0.2.dev41 → 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.dev41
+Version: 3.0.2.dev43
 Summary: SignalWire SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT