signalwire-agents 0.1.20__py3-none-any.whl → 0.1.23__py3-none-any.whl

signalwire_agents/core/swml_renderer.py

@@ -8,12 +8,11 @@ See LICENSE file in the project root for full license information.
 """
 
 """
-SwmlRenderer for generating complete SWML documents for SignalWire AI Agents
+SWML document rendering utilities for SignalWire AI Agents.
 """
 
-from typing import Dict, List, Any, Optional, Union
 import json
-import yaml
+from typing import Dict, List, Any, Optional, Union
 
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_builder import SWMLBuilder
@@ -23,14 +22,13 @@ class SwmlRenderer:
     """
     Renders SWML documents for SignalWire AI Agents with AI and SWAIG components
     
-    This class provides backward-compatible methods for rendering SWML documents
-    while also supporting the new SWMLService architecture. It can work either
-    standalone (legacy mode) or with a SWMLService instance.
+    This class provides methods for rendering SWML documents using the SWMLService architecture.
     """
     
     @staticmethod
     def render_swml(
         prompt: Union[str, List[Dict[str, Any]]],
+        service: SWMLService,
         post_prompt: Optional[str] = None,
         post_prompt_url: Optional[str] = None,
         swaig_functions: Optional[List[Dict[str, Any]]] = None,
@@ -43,341 +41,154 @@ class SwmlRenderer:
         record_format: str = "mp4",
         record_stereo: bool = True,
         format: str = "json",
-        default_webhook_url: Optional[str] = None,
-        service: Optional[SWMLService] = None
+        default_webhook_url: Optional[str] = None
     ) -> str:
         """
         Generate a complete SWML document with AI configuration
         
         Args:
-            prompt: Either a string prompt or a POM in list-of-dict format
-            post_prompt: Optional post-prompt text (for summary)
-            post_prompt_url: URL to receive the post-prompt result
+            prompt: AI prompt text or POM structure
+            service: SWMLService instance to use for document building
+            post_prompt: Optional post-prompt text
+            post_prompt_url: Optional post-prompt URL
             swaig_functions: List of SWAIG function definitions
-            startup_hook_url: URL for startup hook
-            hangup_hook_url: URL for hangup hook
-            prompt_is_pom: Whether prompt is a POM object or raw text
-            params: Additional AI params (temperature, etc)
-            add_answer: Whether to auto-add the answer block after AI
-            record_call: Whether to add a record_call block
-            record_format: Format for recording the call
+            startup_hook_url: Optional startup hook URL
+            hangup_hook_url: Optional hangup hook URL
+            prompt_is_pom: Whether prompt is POM format
+            params: Additional AI verb parameters
+            add_answer: Whether to add answer verb
+            record_call: Whether to add record_call verb
+            record_format: Recording format
             record_stereo: Whether to record in stereo
-            format: Output format, 'json' or 'yaml'
-            default_webhook_url: Optional default webhook URL for all SWAIG functions
-            service: Optional SWMLService instance to use
+            format: Output format (json or yaml)
+            default_webhook_url: Default webhook URL for SWAIG functions
             
         Returns:
             SWML document as a string
         """
-        # If we have a service, use it to build the document
-        if service:
-            # Create a builder for the service
-            builder = SWMLBuilder(service)
-            
-            # Reset the document to start fresh
-            builder.reset()
-            
-            # Add answer block if requested
-            if add_answer:
-                builder.answer()
-            
-            # Add record_call if requested
-            if record_call:
-                # TODO: Add record_call to builder API
-                service.add_verb("record_call", {
-                    "format": record_format,
-                    "stereo": record_stereo
-                })
-            
-            # Configure SWAIG object for AI verb
-            swaig_config = {}
-            functions = []
-            
-            # Add startup hook if provided
-            if startup_hook_url:
-                functions.append({
-                    "function": "startup_hook",
-                    "description": "Called when the call starts",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {}
-                    },
-                    "web_hook_url": startup_hook_url
-                })
-            
-            # Add hangup hook if provided
-            if hangup_hook_url:
-                functions.append({
-                    "function": "hangup_hook",
-                    "description": "Called when the call ends",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {}
-                    },
-                    "web_hook_url": hangup_hook_url
-                })
-            
-            # Add regular functions if provided
-            if swaig_functions:
-                for func in swaig_functions:
-                    # Skip special hooks as we've already added them
-                    if func.get("function") not in ["startup_hook", "hangup_hook"]:
-                        functions.append(func)
-            
-            # Only add SWAIG if we have functions or a default URL
-            if functions or default_webhook_url:
-                swaig_config = {}
-                
-                # Add defaults if we have a default webhook URL
-                if default_webhook_url:
-                    swaig_config["defaults"] = {
-                        "web_hook_url": default_webhook_url
-                    }
-                
-                # Add functions if we have any
-                if functions:
-                    swaig_config["functions"] = functions
-            
-            # Add AI verb with appropriate configuration
-            builder.ai(
-                prompt_text=None if prompt_is_pom else prompt,
-                prompt_pom=prompt if prompt_is_pom else None,
-                post_prompt=post_prompt,
-                post_prompt_url=post_prompt_url,
-                swaig=swaig_config if swaig_config else None,
-                **(params or {})
-            )
-            
-            # Get the document as a dictionary or string based on format
-            if format.lower() == "yaml":
-                import yaml
-                return yaml.dump(builder.build(), sort_keys=False)
-            else:
-                return builder.render()
-        else:
-            # Legacy implementation (unchanged for backward compatibility)
-            # Start building the SWML document
-            swml = {
-                "version": "1.0.0",
-                "sections": {
-                    "main": []
-                }
-            }
-            
-            # Build the AI block
-            ai_block = {
-                "ai": {
-                    "prompt": {}
-                }
-            }
-            
-            # Set prompt based on type
-            if prompt_is_pom:
-                ai_block["ai"]["prompt"]["pom"] = prompt
-            else:
-                ai_block["ai"]["prompt"]["text"] = prompt
-                
-            # Add post_prompt if provided
-            if post_prompt:
-                ai_block["ai"]["post_prompt"] = {
-                    "text": post_prompt
-                }
-                
-            # Add post_prompt_url if provided
-            if post_prompt_url:
-                ai_block["ai"]["post_prompt_url"] = post_prompt_url
-                
-            # SWAIG is a dictionary not an array (fix from old implementation)
-            ai_block["ai"]["SWAIG"] = {}
-            
+        # Use the service to build the document
+        builder = SWMLBuilder(service)
+        
+        # Reset the document to start fresh
+        builder.reset()
+        
+        # Add answer block if requested
+        if add_answer:
+            builder.answer()
+        
+        # Add record_call if requested
+        if record_call:
+            service.add_verb("record_call", {
+                "format": record_format,
+                "stereo": record_stereo
+            })
+        
+        # Configure SWAIG object for AI verb
+        swaig_config = {}
+        functions = []
+        
+        # Add startup hook if provided
+        if startup_hook_url:
+            functions.append({
+                "function": "startup_hook",
+                "description": "Called when the call starts",
+                "parameters": {
+                    "type": "object",
+                    "properties": {}
+                },
+                "web_hook_url": startup_hook_url
+            })
+        
+        # Add hangup hook if provided
+        if hangup_hook_url:
+            functions.append({
+                "function": "hangup_hook",
+                "description": "Called when the call ends",
+                "parameters": {
+                    "type": "object",
+                    "properties": {}
+                },
+                "web_hook_url": hangup_hook_url
+            })
+        
+        # Add regular functions if provided
+        if swaig_functions:
+            for func in swaig_functions:
+                # Skip special hooks as we've already added them
+                if func.get("function") not in ["startup_hook", "hangup_hook"]:
+                    functions.append(func)
+        
+        # Only add SWAIG if we have functions or a default URL
+        if functions or default_webhook_url:
             # Add defaults if we have a default webhook URL
             if default_webhook_url:
-                ai_block["ai"]["SWAIG"]["defaults"] = {
+                swaig_config["defaults"] = {
                     "web_hook_url": default_webhook_url
                 }
             
-            # Collect all functions
-            functions = []
-            
-            # Add SWAIG hooks if provided
-            if startup_hook_url:
-                startup_hook = {
-                    "function": "startup_hook",
-                    "description": "Called when the call starts",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {}
-                    },
-                    "web_hook_url": startup_hook_url
-                }
-                functions.append(startup_hook)
-                
-            if hangup_hook_url:
-                hangup_hook = {
-                    "function": "hangup_hook",
-                    "description": "Called when the call ends",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {}
-                    },
-                    "web_hook_url": hangup_hook_url
-                }
-                functions.append(hangup_hook)
-            
-            # Add regular functions from the provided list
-            if swaig_functions:
-                for func in swaig_functions:
-                    # Skip special hooks as we've already added them
-                    if func.get("function") not in ["startup_hook", "hangup_hook"]:
-                        functions.append(func)
-            
-            # Add functions to SWAIG if we have any
+            # Add functions if we have any
             if functions:
-                ai_block["ai"]["SWAIG"]["functions"] = functions
-                
-            # Add AI params if provided (but not rendering settings)
-            if params:
-                # Filter out non-AI parameters that should be separate SWML methods
-                ai_params = {k: v for k, v in params.items() 
-                             if k not in ["auto_answer", "record_call", "record_format", "record_stereo"]}
-                
-                # Only update if we have valid AI parameters
-                if ai_params:
-                    ai_block["ai"]["params"] = ai_params
-                
-            # Start building the SWML blocks
-            main_blocks = []
-            
-            # Add answer block first if requested (to answer the call)
-            if add_answer:
-                main_blocks.append({"answer": {}})
-                
-            # Add record_call block next if requested
-            if record_call:
-                main_blocks.append({
-                    "record_call": {
-                        "format": record_format,
-                        "stereo": record_stereo  # SWML expects a boolean not a string
-                    }
-                })
-            
-            # Add the AI block
-            main_blocks.append(ai_block)
-            
-            # Set the main section to our ordered blocks
-            swml["sections"]["main"] = main_blocks
-            
-            # Return in requested format
-            if format.lower() == "yaml":
-                import yaml
-                return yaml.dump(swml, sort_keys=False)
-            else:
-                return json.dumps(swml, indent=2)
+                swaig_config["functions"] = functions
+        
+        # Add AI verb with appropriate configuration
+        builder.ai(
+            prompt_text=None if prompt_is_pom else prompt,
+            prompt_pom=prompt if prompt_is_pom else None,
+            post_prompt=post_prompt,
+            post_prompt_url=post_prompt_url,
+            swaig=swaig_config if swaig_config else None,
+            **(params or {})
+        )
+        
+        # Get the document as a dictionary or string based on format
+        if format.lower() == "yaml":
+            import yaml
+            return yaml.dump(builder.build(), sort_keys=False)
+        else:
+            return builder.render()
             
     @staticmethod
     def render_function_response_swml(
         response_text: str,
+        service: SWMLService,
         actions: Optional[List[Dict[str, Any]]] = None,
-        format: str = "json",
-        service: Optional[SWMLService] = None
+        format: str = "json"
     ) -> str:
         """
         Generate a SWML document for a function response
         
         Args:
-            response_text: Text to say/display
-            actions: List of SWML actions to execute
-            format: Output format, 'json' or 'yaml'
-            service: Optional SWMLService instance to use
+            response_text: Text response to include in the document
+            service: SWMLService instance to use
+            actions: Optional list of actions to perform
+            format: Output format (json or yaml)
             
         Returns:
             SWML document as a string
         """
-        if service:
-            # Use the service to build the document
-            service.reset_document()
-            
-            # Add a play block for the response if provided
-            if response_text:
-                service.add_verb("play", {
-                    "url": f"say:{response_text}"
-                })
-                
-            # Add any actions
-            if actions:
-                for action in actions:
-                    # Support both type-based actions and direct SWML verbs
-                    if "type" in action:
-                        # Type-based action format
-                        if action["type"] == "play":
-                            service.add_verb("play", {
-                                "url": action["url"]
-                            })
-                        elif action["type"] == "transfer":
-                            service.add_verb("connect", [
-                                {"to": action["dest"]}
-                            ])
-                        elif action["type"] == "hang_up":
-                            service.add_verb("hangup", {})
-                        # Additional action types could be added here
-                    else:
-                        # Direct SWML verb format
-                        for verb_name, verb_config in action.items():
-                            service.add_verb(verb_name, verb_config)
-            
-            # Return in requested format
-            if format.lower() == "yaml":
-                import yaml
-                return yaml.dump(service.get_document(), sort_keys=False)
-            else:
-                return service.render_document()
+        # Use the service to build the document
+        service.reset_document()
+        
+        # Add a play block for the response if provided
+        if response_text:
+            service.add_verb("play", {"text": response_text})
+        
+        # Add any actions that were provided
+        if actions:
+            for action in actions:
+                if "play" in action:
+                    service.add_verb("play", action["play"])
+                elif "hangup" in action:
+                    service.add_verb("hangup", action["hangup"])
+                elif "transfer" in action:
+                    service.add_verb("transfer", action["transfer"])
+                elif "ai" in action:
+                    service.add_verb("ai", action["ai"])
+                # Add more action types as needed
+        
+        # Get the document as a dictionary or string based on format
+        if format.lower() == "yaml":
+            import yaml
+            return yaml.dump(service.get_document(), sort_keys=False)
         else:
-            # Legacy implementation (unchanged for backward compatibility)
-            swml = {
-                "version": "1.0.0",
-                "sections": {
-                    "main": []
-                }
-            }
-            
-            # Add a play block for the response if provided
-            if response_text:
-                swml["sections"]["main"].append({
-                    "play": {
-                        "url": f"say:{response_text}"
-                    }
-                })
-                
-            # Add any actions
-            if actions:
-                for action in actions:
-                    # Support both type-based actions and direct SWML verbs
-                    if "type" in action:
-                        # Type-based action format
-                        if action["type"] == "play":
-                            swml["sections"]["main"].append({
-                                "play": {
-                                    "url": action["url"]
-                                }
-                            })
-                        elif action["type"] == "transfer":
-                            swml["sections"]["main"].append({
-                                "connect": [
-                                    {"to": action["dest"]}
-                                ]
-                            })
-                        elif action["type"] == "hang_up":
-                            swml["sections"]["main"].append({
-                                "hangup": {}
-                            })
-                        # Additional action types could be added here
-                    else:
-                        # Direct SWML verb format - add the action as-is
-                        swml["sections"]["main"].append(action)
-                    
-            # Return in requested format
-            if format.lower() == "yaml":
-                import yaml
-                return yaml.dump(swml, sort_keys=False)
-            else:
-                return json.dumps(swml)
+            return service.render_document()

signalwire_agents/core/swml_service.py

@@ -82,8 +82,13 @@ class SWMLService:
         self.route = route.rstrip("/")  # Ensure no trailing slash
         self.host = host
         self.port = port
-        self.ssl_enabled = False
-        self.domain = None
+        
+        # Initialize SSL configuration from environment variables
+        ssl_enabled_env = os.environ.get('SWML_SSL_ENABLED', '').lower()
+        self.ssl_enabled = ssl_enabled_env in ('true', '1', 'yes')
+        self.domain = os.environ.get('SWML_DOMAIN')
+        self.ssl_cert_path = os.environ.get('SWML_SSL_CERT_PATH')
+        self.ssl_key_path = os.environ.get('SWML_SSL_KEY_PATH')
         
         # Initialize proxy detection attributes
         self._proxy_url_base = os.environ.get('SWML_PROXY_URL_BASE')
@@ -749,13 +754,15 @@ class SWMLService:
         """
         import uvicorn
         
-        # Store SSL configuration
-        self.ssl_enabled = ssl_enabled if ssl_enabled is not None else False
-        self.domain = domain
+        # Store SSL configuration (override environment if explicitly provided)
+        if ssl_enabled is not None:
+            self.ssl_enabled = ssl_enabled
+        if domain is not None:
+            self.domain = domain
         
-        # Set SSL paths
-        ssl_cert_path = ssl_cert
-        ssl_key_path = ssl_key
+        # Set SSL paths (use provided paths or fall back to environment)
+        ssl_cert_path = ssl_cert or getattr(self, 'ssl_cert_path', None)
+        ssl_key_path = ssl_key or getattr(self, 'ssl_key_path', None)
         
         # Validate SSL configuration if enabled
         if self.ssl_enabled:
@@ -838,7 +845,14 @@ class SWMLService:
         
         # Use correct protocol and host in displayed URL
         protocol = "https" if self.ssl_enabled else "http"
-        display_host = self.domain if self.ssl_enabled and self.domain else f"{host}:{port}"
+        
+        # Determine display host - include port unless it's the standard port for the protocol
+        if self.ssl_enabled and self.domain:
+            # Use domain, but include port if it's not the standard HTTPS port (443)
+            display_host = f"{self.domain}:{port}" if port != 443 else self.domain
+        else:
+            # Use host:port for HTTP or when no domain is specified
+            display_host = f"{host}:{port}"
         
         self.log.info("starting_server", 
                      url=f"{protocol}://{display_host}{self.route}",
@@ -932,90 +946,6 @@ class SWMLService:
         
         return username, password
     
-    # Keep the existing methods for backward compatibility
-    
-    def add_answer_verb(self, max_duration: Optional[int] = None, codecs: Optional[str] = None) -> bool:
-        """
-        Add an answer verb to the current document
-        
-        Args:
-            max_duration: Maximum duration in seconds
-            codecs: Comma-separated list of codecs
-            
-        Returns:
-            True if added successfully, False otherwise
-        """
-        config = {}
-        if max_duration is not None:
-            config["max_duration"] = max_duration
-        if codecs is not None:
-            config["codecs"] = codecs
-            
-        return self.add_verb("answer", config)
-    
-    def add_hangup_verb(self, reason: Optional[str] = None) -> bool:
-        """
-        Add a hangup verb to the current document
-        
-        Args:
-            reason: Hangup reason (hangup, busy, decline)
-            
-        Returns:
-            True if added successfully, False otherwise
-        """
-        config = {}
-        if reason is not None:
-            config["reason"] = reason
-            
-        return self.add_verb("hangup", config)
-    
-    def add_ai_verb(self, 
-               prompt_text: Optional[str] = None,
-               prompt_pom: Optional[List[Dict[str, Any]]] = None,
-               post_prompt: Optional[str] = None,
-               post_prompt_url: Optional[str] = None,
-               swaig: Optional[Dict[str, Any]] = None,
-               **kwargs) -> bool:
-        """
-        Add an AI verb to the current document
-        
-        Args:
-            prompt_text: Simple prompt text
-            prompt_pom: Prompt object model
-            post_prompt: Post-prompt text
-            post_prompt_url: Post-prompt URL
-            swaig: SWAIG configuration
-            **kwargs: Additional parameters
-            
-        Returns:
-            True if added successfully, False otherwise
-        """
-        config = {}
-        
-        # Handle prompt
-        if prompt_text is not None:
-            config["prompt"] = prompt_text
-        elif prompt_pom is not None:
-            config["prompt"] = prompt_pom
-            
-        # Handle post prompt
-        if post_prompt is not None:
-            config["post_prompt"] = post_prompt
-        
-        # Handle post prompt URL
-        if post_prompt_url is not None:
-            config["post_prompt_url"] = post_prompt_url
-            
-        # Handle SWAIG
-        if swaig is not None:
-            config["SWAIG"] = swaig
-            
-        # Handle additional parameters
-        for key, value in kwargs.items():
-            if value is not None:
-                config[key] = value
-                
-        return self.add_verb("ai", config)
         
     def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
         """
@@ -1043,7 +973,8 @@ class SWMLService:
             
             # Use domain if available and SSL is enabled
             if getattr(self, 'ssl_enabled', False) and getattr(self, 'domain', None):
-                host_part = self.domain
+                # Use domain, but include port if it's not the standard HTTPS port (443)
+                host_part = f"{self.domain}:{self.port}" if self.port != 443 else self.domain
             else:
                 # For local URLs
                 if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):

signalwire_agents/search/index_builder.py

@@ -203,7 +203,7 @@ class IndexBuilder:
                    file_types: List[str], exclude_patterns: Optional[List[str]] = None,
                    languages: List[str] = None, tags: Optional[List[str]] = None):
         """
-        Build complete search index from a single directory (legacy method)
+        Build complete search index from a single directory
         
         Args:
             source_dir: Directory to scan for documents

signalwire_agents/skills/api_ninjas_trivia/__init__.py

@@ -0,0 +1,3 @@
+from .skill import ApiNinjasTriviaSkill
+
+__all__ = ['ApiNinjasTriviaSkill']