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

signalwire_agents/__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__ = "0.1.20"
+__version__ = "0.1.23"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents/agent_server.py

@@ -11,6 +11,7 @@ See LICENSE file in the project root for full license information.
 AgentServer - Class for hosting multiple SignalWire AI Agents in a single server
 """
 
+import os
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
@@ -575,24 +576,62 @@ class AgentServer:
             # No matching agent found
             return {"error": "Not Found"}
             
-        # Print server info
+        # Set host and port
         host = host or self.host
         port = port or self.port
         
-        self.logger.info(f"Starting server on {host}:{port}")
+        # Check for SSL configuration from environment variables
+        ssl_enabled_env = os.environ.get('SWML_SSL_ENABLED', '').lower()
+        ssl_enabled = ssl_enabled_env in ('true', '1', 'yes')
+        ssl_cert_path = os.environ.get('SWML_SSL_CERT_PATH')
+        ssl_key_path = os.environ.get('SWML_SSL_KEY_PATH')
+        domain = os.environ.get('SWML_DOMAIN')
+        
+        # Validate SSL configuration if enabled
+        if ssl_enabled:
+            if not ssl_cert_path or not os.path.exists(ssl_cert_path):
+                self.logger.warning(f"SSL cert not found: {ssl_cert_path}")
+                ssl_enabled = False
+            elif not ssl_key_path or not os.path.exists(ssl_key_path):
+                self.logger.warning(f"SSL key not found: {ssl_key_path}")
+                ssl_enabled = False
+        
+        # Update server info display with correct protocol
+        protocol = "https" if ssl_enabled else "http"
+        
+        # Determine display host - include port unless it's the standard port for the protocol
+        if ssl_enabled and domain:
+            # Use domain, but include port if it's not the standard HTTPS port (443)
+            display_host = f"{domain}:{port}" if port != 443 else domain
+        else:
+            # Use host:port for HTTP or when no domain is specified
+            display_host = f"{host}:{port}"
+        
+        self.logger.info(f"Starting server on {protocol}://{display_host}")
         for route, agent in self.agents.items():
             username, password = agent.get_basic_auth_credentials()
             self.logger.info(f"Agent '{agent.get_name()}' available at:")
-            self.logger.info(f"URL: http://{host}:{port}{route}")
+            self.logger.info(f"URL: {protocol}://{display_host}{route}")
             self.logger.info(f"Basic Auth: {username}:{password}")
-            
-        # Start the server
-        uvicorn.run(
-            self.app,
-            host=host,
-            port=port,
-            log_level=self.log_level
-        )
+        
+        # Start the server with or without SSL
+        if ssl_enabled and ssl_cert_path and ssl_key_path:
+            self.logger.info(f"Starting with SSL - cert: {ssl_cert_path}, key: {ssl_key_path}")
+            uvicorn.run(
+                self.app,
+                host=host,
+                port=port,
+                log_level=self.log_level,
+                ssl_certfile=ssl_cert_path,
+                ssl_keyfile=ssl_key_path
+            )
+        else:
+            uvicorn.run(
+                self.app,
+                host=host,
+                port=port,
+                log_level=self.log_level
+            )
 
     def register_global_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]], 
                                         path: str) -> None:

signalwire_agents/core/__init__.py

@@ -13,7 +13,7 @@ Core components for SignalWire AI Agents
 
 from signalwire_agents.core.agent_base import AgentBase
 from signalwire_agents.core.function_result import SwaigFunctionResult
-from signalwire_agents.core.swaig_function import SwaigFunction
+from signalwire_agents.core.swaig_function import SWAIGFunction
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_handler import SWMLVerbHandler, VerbHandlerRegistry
 from signalwire_agents.core.swml_builder import SWMLBuilder
@@ -21,7 +21,7 @@ from signalwire_agents.core.swml_builder import SWMLBuilder
 __all__ = [
     'AgentBase', 
     'SwaigFunctionResult', 
-    'SwaigFunction',
+    'SWAIGFunction',
     'SWMLService',
     'SWMLVerbHandler',
     'VerbHandlerRegistry',

signalwire_agents/core/agent/__init__.py

@@ -0,0 +1,14 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Agent refactored components."""
+
+from .config.ephemeral import EphemeralAgentConfig
+
+__all__ = ['EphemeralAgentConfig']

signalwire_agents/core/agent/config/__init__.py

@@ -0,0 +1,14 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Configuration management modules."""
+
+from .ephemeral import EphemeralAgentConfig
+
+__all__ = ['EphemeralAgentConfig']

signalwire_agents/core/agent/config/ephemeral.py

@@ -0,0 +1,176 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Ephemeral agent configuration for dynamic per-request settings."""
+
+from typing import Dict, Any, Optional, List
+
+
+class EphemeralAgentConfig:
+    """
+    An ephemeral configurator object that mimics AgentBase's configuration interface.
+    
+    This allows dynamic configuration callbacks to use the same familiar methods
+    they would use during agent initialization, but for per-request configuration.
+    """
+    
+    def __init__(self):
+        # Initialize all configuration containers
+        self._hints = []
+        self._languages = []
+        self._pronounce = []
+        self._params = {}
+        self._global_data = {}
+        self._prompt_sections = []
+        self._raw_prompt = None
+        self._post_prompt = None
+        self._function_includes = []
+        self._native_functions = []
+    
+    # Mirror all the AgentBase configuration methods
+    
+    def add_hint(self, hint: str) -> 'EphemeralAgentConfig':
+        """Add a simple string hint"""
+        if isinstance(hint, str) and hint:
+            self._hints.append(hint)
+        return self
+    
+    def add_hints(self, hints: List[str]) -> 'EphemeralAgentConfig':
+        """Add multiple string hints"""
+        if hints and isinstance(hints, list):
+            for hint in hints:
+                if isinstance(hint, str) and hint:
+                    self._hints.append(hint)
+        return self
+    
+    def add_language(self, name: str, code: str, voice: str, **kwargs) -> 'EphemeralAgentConfig':
+        """Add a language configuration"""
+        language = {
+            "name": name,
+            "code": code,
+            "voice": voice
+        }
+        
+        # Handle additional parameters
+        for key, value in kwargs.items():
+            if key in ["engine", "model", "speech_fillers", "function_fillers", "fillers"]:
+                language[key] = value
+        
+        self._languages.append(language)
+        return self
+    
+    def add_pronunciation(self, replace: str, with_text: str, ignore_case: bool = False) -> 'EphemeralAgentConfig':
+        """Add a pronunciation rule"""
+        if replace and with_text:
+            rule = {"replace": replace, "with": with_text}
+            if ignore_case:
+                rule["ignore_case"] = True
+            self._pronounce.append(rule)
+        return self
+    
+    def set_param(self, key: str, value: Any) -> 'EphemeralAgentConfig':
+        """Set a single AI parameter"""
+        if key:
+            self._params[key] = value
+        return self
+    
+    def set_params(self, params: Dict[str, Any]) -> 'EphemeralAgentConfig':
+        """Set multiple AI parameters"""
+        if params and isinstance(params, dict):
+            self._params.update(params)
+        return self
+    
+    def set_global_data(self, data: Dict[str, Any]) -> 'EphemeralAgentConfig':
+        """Set global data"""
+        if data and isinstance(data, dict):
+            self._global_data = data
+        return self
+    
+    def update_global_data(self, data: Dict[str, Any]) -> 'EphemeralAgentConfig':
+        """Update global data"""
+        if data and isinstance(data, dict):
+            self._global_data.update(data)
+        return self
+    
+    def set_prompt_text(self, text: str) -> 'EphemeralAgentConfig':
+        """Set raw prompt text"""
+        self._raw_prompt = text
+        return self
+    
+    def set_post_prompt(self, text: str) -> 'EphemeralAgentConfig':
+        """Set post-prompt text"""
+        self._post_prompt = text
+        return self
+    
+    def prompt_add_section(self, title: str, body: str = "", bullets: Optional[List[str]] = None, **kwargs) -> 'EphemeralAgentConfig':
+        """Add a prompt section"""
+        section = {
+            "title": title,
+            "body": body
+        }
+        if bullets:
+            section["bullets"] = bullets
+        
+        # Handle additional parameters
+        for key, value in kwargs.items():
+            if key in ["numbered", "numbered_bullets", "subsections"]:
+                section[key] = value
+        
+        self._prompt_sections.append(section)
+        return self
+    
+    def set_native_functions(self, function_names: List[str]) -> 'EphemeralAgentConfig':
+        """Set native functions"""
+        if function_names and isinstance(function_names, list):
+            self._native_functions = [name for name in function_names if isinstance(name, str)]
+        return self
+    
+    def add_function_include(self, url: str, functions: List[str], meta_data: Optional[Dict[str, Any]] = None) -> 'EphemeralAgentConfig':
+        """Add a function include"""
+        if url and functions and isinstance(functions, list):
+            include = {"url": url, "functions": functions}
+            if meta_data and isinstance(meta_data, dict):
+                include["meta_data"] = meta_data
+            self._function_includes.append(include)
+        return self
+    
+    def extract_config(self) -> Dict[str, Any]:
+        """
+        Extract the configuration as a dictionary for applying to the real agent.
+        
+        Returns:
+            Dictionary containing all the configuration changes
+        """
+        config = {}
+        
+        if self._hints:
+            config["hints"] = self._hints
+        if self._languages:
+            config["languages"] = self._languages
+        if self._pronounce:
+            config["pronounce"] = self._pronounce
+        if self._params:
+            config["params"] = self._params
+        if self._global_data:
+            config["global_data"] = self._global_data
+        if self._function_includes:
+            config["function_includes"] = self._function_includes
+        if self._native_functions:
+            config["native_functions"] = self._native_functions
+        
+        # Handle prompt sections - these should be applied to the agent's POM, not as raw config
+        # The calling code should use these to build the prompt properly
+        if self._prompt_sections:
+            config["_ephemeral_prompt_sections"] = self._prompt_sections
+        if self._raw_prompt:
+            config["_ephemeral_raw_prompt"] = self._raw_prompt
+        if self._post_prompt:
+            config["_ephemeral_post_prompt"] = self._post_prompt
+        
+        return config

signalwire_agents/core/agent/prompt/__init__.py

@@ -0,0 +1,14 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Prompt management modules."""
+
+from .manager import PromptManager
+
+__all__ = ['PromptManager']

signalwire_agents/core/agent/prompt/manager.py

@@ -0,0 +1,288 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Prompt management functionality for AgentBase."""
+
+from typing import Dict, Any, Optional, List, Union
+import inspect
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class PromptManager:
+    """Manages prompt building and configuration."""
+    
+    def __init__(self, agent):
+        """
+        Initialize PromptManager with reference to parent agent.
+        
+        Args:
+            agent: Parent AgentBase instance
+        """
+        self.agent = agent
+        self._prompt_text = None
+        self._post_prompt_text = None
+        self._contexts = None
+    
+    def _validate_prompt_mode_exclusivity(self):
+        """
+        Check that only one prompt mode is in use.
+        
+        Raises:
+            ValueError: If both prompt modes are in use
+        """
+        if self._prompt_text and self.agent._use_pom and self.agent.pom:
+            pom_sections = self.agent.pom.to_dict() if hasattr(self.agent.pom, 'to_dict') else []
+            if pom_sections:
+                raise ValueError(
+                    "Cannot use both prompt_text and POM sections. "
+                    "Please use either set_prompt_text() OR the prompt_add_* methods, not both."
+                )
+    
+    def _process_prompt_sections(self) -> Optional[Union[str, List[Dict[str, Any]]]]:
+        """
+        Process prompt sections from POM or raw prompt text.
+        
+        Returns:
+            String, List of section dictionaries, or None
+        """
+        # First check if we have contexts - they take precedence
+        if self._contexts:
+            return None  # Contexts handle their own prompt sections
+            
+        # Check if we have a raw prompt text - return it directly
+        if self._prompt_text:
+            return self._prompt_text
+        
+        # Otherwise use POM sections if available
+        if self.agent._use_pom and self.agent.pom:
+            sections = self.agent.pom.to_dict()
+            if sections:
+                return sections
+        
+        return None
+    
+    def define_contexts(self, contexts: Union[Dict[str, Any], Any]) -> None:
+        """
+        Define contexts for the agent.
+        
+        Args:
+            contexts: Context configuration (dict or ContextBuilder)
+        """
+        if hasattr(contexts, 'to_dict'):
+            # It's a ContextBuilder
+            self._contexts = contexts.to_dict()
+        elif isinstance(contexts, dict):
+            # It's already a dictionary
+            self._contexts = contexts
+        else:
+            raise ValueError("contexts must be a dictionary or a ContextBuilder object")
+        
+        logger.debug(f"Defined contexts: {self._contexts}")
+    
+    def set_prompt_text(self, text: str) -> None:
+        """
+        Set the agent's prompt as raw text.
+        
+        Args:
+            text: Prompt text
+        """
+        self._validate_prompt_mode_exclusivity()
+        self._prompt_text = text
+        logger.debug(f"Set prompt text: {text[:100]}...")
+    
+    def set_post_prompt(self, text: str) -> None:
+        """
+        Set the post-prompt text.
+        
+        Args:
+            text: Post-prompt text
+        """
+        self._post_prompt_text = text
+        logger.debug(f"Set post-prompt text: {text[:100]}...")
+    
+    def set_prompt_pom(self, pom: List[Dict[str, Any]]) -> None:
+        """
+        Set the prompt as a POM dictionary.
+        
+        Args:
+            pom: POM dictionary structure
+            
+        Raises:
+            ValueError: If use_pom is False
+        """
+        if self.agent._use_pom:
+            self.agent.pom = pom
+        else:
+            raise ValueError("use_pom must be True to use set_prompt_pom")
+    
+    def prompt_add_section(
+        self, 
+        title: str, 
+        body: str = "", 
+        bullets: Optional[List[str]] = None,
+        numbered: bool = False,
+        numbered_bullets: bool = False,
+        subsections: Optional[List[Dict[str, Any]]] = None
+    ) -> None:
+        """
+        Add a section to the prompt.
+        
+        Args:
+            title: Section title
+            body: Optional section body text
+            bullets: Optional list of bullet points
+            numbered: Whether this section should be numbered
+            numbered_bullets: Whether bullets should be numbered
+            subsections: Optional list of subsection objects
+        """
+        self._validate_prompt_mode_exclusivity()
+        if self.agent._use_pom and self.agent.pom:
+            # Create parameters for add_section based on what's supported
+            kwargs = {}
+            
+            # Start with basic parameters
+            kwargs['title'] = title
+            kwargs['body'] = body
+            if bullets:
+                kwargs['bullets'] = bullets
+            
+            # Add optional parameters if they look supported
+            if hasattr(self.agent.pom, 'add_section'):
+                sig = inspect.signature(self.agent.pom.add_section)
+                if 'numbered' in sig.parameters:
+                    kwargs['numbered'] = numbered
+                if 'numberedBullets' in sig.parameters:
+                    kwargs['numberedBullets'] = numbered_bullets
+            
+            # Create the section
+            section = self.agent.pom.add_section(**kwargs)
+            
+            # Now add subsections if provided, by calling add_subsection on the section
+            if subsections:
+                for subsection in subsections:
+                    if 'title' in subsection:
+                        section.add_subsection(
+                            title=subsection.get('title'),
+                            body=subsection.get('body', ''),
+                            bullets=subsection.get('bullets', [])
+                        )
+    
+    def prompt_add_to_section(
+        self,
+        title: str,
+        body: Optional[str] = None,
+        bullet: Optional[str] = None,
+        bullets: Optional[List[str]] = None
+    ) -> None:
+        """
+        Add content to an existing section (creating it if needed).
+        
+        Args:
+            title: Section title
+            body: Optional text to append to section body
+            bullet: Optional single bullet point to add
+            bullets: Optional list of bullet points to add
+        """
+        if self.agent._use_pom and self.agent.pom:
+            self.agent.pom.add_to_section(
+                title=title,
+                body=body,
+                bullet=bullet,
+                bullets=bullets
+            )
+    
+    def prompt_add_subsection(
+        self,
+        parent_title: str,
+        title: str,
+        body: str = "",
+        bullets: Optional[List[str]] = None
+    ) -> None:
+        """
+        Add a subsection to an existing section (creating parent if needed).
+        
+        Args:
+            parent_title: Parent section title
+            title: Subsection title
+            body: Optional subsection body text
+            bullets: Optional list of bullet points
+        """
+        if self.agent._use_pom and self.agent.pom:
+            # First find or create the parent section
+            parent_section = None
+            
+            # Try to find the parent section by title
+            if hasattr(self.agent.pom, 'sections'):
+                for section in self.agent.pom.sections:
+                    if hasattr(section, 'title') and section.title == parent_title:
+                        parent_section = section
+                        break
+            
+            # If parent section not found, create it
+            if not parent_section:
+                parent_section = self.agent.pom.add_section(title=parent_title)
+            
+            # Now call add_subsection on the parent section object, not on POM
+            parent_section.add_subsection(
+                title=title,
+                body=body,
+                bullets=bullets or []
+            )
+    
+    def prompt_has_section(self, title: str) -> bool:
+        """
+        Check if a section exists in the prompt.
+        
+        Args:
+            title: Section title to check
+            
+        Returns:
+            True if section exists, False otherwise
+        """
+        if self.agent._use_pom and self.agent.pom:
+            return self.agent.pom.has_section(title)
+        return False
+    
+    def get_prompt(self) -> Optional[Union[str, List[Dict[str, Any]]]]:
+        """
+        Get the prompt configuration.
+        
+        Returns:
+            Prompt text or sections or None
+        """
+        return self._process_prompt_sections()
+    
+    def get_raw_prompt(self) -> Optional[str]:
+        """
+        Get the raw prompt text if set.
+        
+        Returns:
+            Raw prompt text or None
+        """
+        return self._prompt_text
+    
+    def get_post_prompt(self) -> Optional[str]:
+        """
+        Get the post-prompt text.
+        
+        Returns:
+            Post-prompt text or None
+        """
+        return self._post_prompt_text
+    
+    def get_contexts(self) -> Optional[Dict[str, Any]]:
+        """
+        Get the contexts configuration.
+        
+        Returns:
+            Contexts dict or None
+        """
+        return self._contexts

signalwire_agents/core/agent/tools/__init__.py

@@ -0,0 +1,15 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""Tool management modules."""
+
+from .registry import ToolRegistry
+from .decorator import ToolDecorator
+
+__all__ = ['ToolRegistry', 'ToolDecorator']