signalwire-agents 0.1.28__tar.gz → 0.1.29__tar.gz

{signalwire_agents-0.1.28 → signalwire_agents-0.1.29}/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## [0.1.29] - 2025-06-23
+
+- Version bump
+
 ## [0.1.28] - 2025-06-23
 
 - Version bump

{signalwire_agents-0.1.28/signalwire_agents.egg-info → signalwire_agents-0.1.29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.28
+Version: 0.1.29
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_agents-0.1.28 → signalwire_agents-0.1.29}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "signalwire_agents"
-version = "0.1.28"
+version = "0.1.29"
 description = "SignalWire AI Agents SDK"
 authors = [
     {name = "SignalWire Team", email = "info@signalwire.com"}

{signalwire_agents-0.1.28 → signalwire_agents-0.1.29}/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.28"
+__version__ = "0.1.29"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents-0.1.29/signalwire_agents/core/auth_handler.py

@@ -0,0 +1,233 @@
+"""
+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.
+"""
+
+import secrets
+from typing import Optional, Tuple, Dict, Any, Callable
+from functools import wraps
+
+try:
+    from fastapi import HTTPException, Depends
+    from fastapi.security import HTTPBasic, HTTPBasicCredentials, HTTPBearer, HTTPAuthorizationCredentials
+except ImportError:
+    HTTPException = None
+    Depends = None
+    HTTPBasic = None
+    HTTPBasicCredentials = None
+    HTTPBearer = None
+    HTTPAuthorizationCredentials = None
+
+from signalwire_agents.core.logging_config import get_logger
+
+logger = get_logger("auth_handler")
+
+
+class AuthHandler:
+    """
+    Unified authentication handler supporting multiple auth methods.
+    
+    This class provides a clean pattern for handling Basic Auth, Bearer tokens,
+    and API keys across all SignalWire services.
+    """
+    
+    def __init__(self, security_config: 'SecurityConfig'):
+        """
+        Initialize auth handler with security configuration.
+        
+        Args:
+            security_config: SecurityConfig instance with auth settings
+        """
+        self.security_config = security_config
+        self.basic_auth = HTTPBasic() if HTTPBasic else None
+        self.bearer_auth = HTTPBearer(auto_error=False) if HTTPBearer else None
+        
+        # Get auth methods from config
+        self._setup_auth_methods()
+    
+    def _setup_auth_methods(self):
+        """Setup enabled authentication methods from config"""
+        self.auth_methods = {}
+        
+        # Basic auth (always available for backward compatibility)
+        username, password = self.security_config.get_basic_auth()
+        self.auth_methods['basic'] = {
+            'enabled': True,
+            'username': username,
+            'password': password
+        }
+        
+        # Bearer token (if configured)
+        bearer_token = getattr(self.security_config, 'bearer_token', None)
+        if bearer_token:
+            self.auth_methods['bearer'] = {
+                'enabled': True,
+                'token': bearer_token
+            }
+        
+        # API key (if configured)
+        api_key = getattr(self.security_config, 'api_key', None)
+        if api_key:
+            self.auth_methods['api_key'] = {
+                'enabled': True,
+                'key': api_key,
+                'header': getattr(self.security_config, 'api_key_header', 'X-API-Key')
+            }
+    
+    def verify_basic_auth(self, credentials: HTTPBasicCredentials) -> bool:
+        """Verify basic auth credentials"""
+        if not self.auth_methods.get('basic', {}).get('enabled'):
+            return False
+            
+        basic_config = self.auth_methods['basic']
+        username_correct = secrets.compare_digest(
+            credentials.username, basic_config['username']
+        )
+        password_correct = secrets.compare_digest(
+            credentials.password, basic_config['password']
+        )
+        
+        return username_correct and password_correct
+    
+    def verify_bearer_token(self, credentials: HTTPAuthorizationCredentials) -> bool:
+        """Verify bearer token"""
+        if not self.auth_methods.get('bearer', {}).get('enabled'):
+            return False
+            
+        bearer_config = self.auth_methods['bearer']
+        return secrets.compare_digest(
+            credentials.credentials, bearer_config['token']
+        )
+    
+    def verify_api_key(self, api_key: str) -> bool:
+        """Verify API key"""
+        if not self.auth_methods.get('api_key', {}).get('enabled'):
+            return False
+            
+        api_config = self.auth_methods['api_key']
+        return secrets.compare_digest(api_key, api_config['key'])
+    
+    def get_fastapi_dependency(self, optional: bool = False):
+        """
+        Get FastAPI dependency for authentication.
+        
+        Args:
+            optional: If True, authentication is optional
+            
+        Returns:
+            FastAPI dependency function
+        """
+        if not Depends:
+            return None
+            
+        async def auth_dependency(
+            basic_credentials: Optional[HTTPBasicCredentials] = Depends(self.basic_auth) if self.basic_auth else None,
+            bearer_credentials: Optional[HTTPAuthorizationCredentials] = Depends(self.bearer_auth) if self.bearer_auth else None,
+            api_key: Optional[str] = None  # Get from header in request
+        ):
+            # Try each auth method
+            authenticated = False
+            auth_method = None
+            
+            # Try bearer token first (if provided)
+            if bearer_credentials and self.verify_bearer_token(bearer_credentials):
+                authenticated = True
+                auth_method = 'bearer'
+            
+            # Try basic auth
+            elif basic_credentials and self.verify_basic_auth(basic_credentials):
+                authenticated = True
+                auth_method = 'basic'
+            
+            # Try API key (would need to be extracted from request headers)
+            # This is a simplified version - in practice, you'd get it from request
+            
+            if not authenticated and not optional:
+                raise HTTPException(
+                    status_code=401,
+                    detail="Invalid authentication credentials",
+                    headers={"WWW-Authenticate": "Basic"},
+                )
+            
+            return {'authenticated': authenticated, 'method': auth_method}
+        
+        return auth_dependency
+    
+    def flask_decorator(self, f: Callable) -> Callable:
+        """
+        Flask decorator for authentication.
+        
+        This provides compatibility with Flask-based services like MCP Gateway.
+        """
+        @wraps(f)
+        def decorated(*args, **kwargs):
+            from flask import request, Response
+            
+            # Try Bearer token first
+            auth_header = request.headers.get('Authorization', '')
+            
+            if auth_header.startswith('Bearer ') and self.auth_methods.get('bearer', {}).get('enabled'):
+                token = auth_header[7:]
+                if secrets.compare_digest(token, self.auth_methods['bearer']['token']):
+                    return f(*args, **kwargs)
+            
+            # Try API key
+            if self.auth_methods.get('api_key', {}).get('enabled'):
+                api_config = self.auth_methods['api_key']
+                api_key = request.headers.get(api_config['header'])
+                if api_key and secrets.compare_digest(api_key, api_config['key']):
+                    return f(*args, **kwargs)
+            
+            # Fall back to Basic auth
+            auth = request.authorization
+            if auth and self.auth_methods.get('basic', {}).get('enabled'):
+                basic_config = self.auth_methods['basic']
+                if auth.username == basic_config['username'] and \
+                   auth.password == basic_config['password']:
+                    return f(*args, **kwargs)
+            
+            # Authentication failed
+            logger.warning(
+                "auth_failed",
+                ip=request.remote_addr,
+                method=request.method,
+                path=request.path
+            )
+            
+            return Response(
+                'Authentication required',
+                401,
+                {'WWW-Authenticate': 'Basic realm="SignalWire Service"'}
+            )
+        
+        return decorated
+    
+    def get_auth_info(self) -> Dict[str, Any]:
+        """Get information about configured auth methods"""
+        info = {}
+        
+        if self.auth_methods.get('basic', {}).get('enabled'):
+            info['basic'] = {
+                'enabled': True,
+                'username': self.auth_methods['basic']['username']
+            }
+        
+        if self.auth_methods.get('bearer', {}).get('enabled'):
+            info['bearer'] = {
+                'enabled': True,
+                'hint': 'Use Authorization: Bearer <token>'
+            }
+        
+        if self.auth_methods.get('api_key', {}).get('enabled'):
+            api_config = self.auth_methods['api_key']
+            info['api_key'] = {
+                'enabled': True,
+                'header': api_config['header'],
+                'hint': f'Use {api_config["header"]}: <key>'
+            }
+        
+        return info

signalwire_agents-0.1.29/signalwire_agents/core/config_loader.py

@@ -0,0 +1,259 @@
+"""
+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.
+"""
+
+import os
+import re
+import json
+from typing import Any, Dict, List, Optional, Union
+from signalwire_agents.core.logging_config import get_logger
+
+logger = get_logger("config_loader")
+
+
+class ConfigLoader:
+    """
+    Configuration loader with environment variable substitution.
+    
+    Supports ${VAR|default} syntax for referencing environment variables
+    within JSON configuration files. This provides a clean pattern for
+    configuration across all SignalWire services.
+    """
+    
+    def __init__(self, config_paths: Optional[List[str]] = None):
+        """
+        Initialize config loader.
+        
+        Args:
+            config_paths: Optional list of config file paths to check.
+                         If not provided, uses default search paths.
+        """
+        self.config_paths = config_paths or self._get_default_paths()
+        self._config = None
+        self._config_file = None
+        self._load_config()
+    
+    def _get_default_paths(self) -> List[str]:
+        """Get default configuration file search paths."""
+        return [
+            "config.json",
+            "agent_config.json",
+            "swml_config.json",
+            ".swml/config.json",
+            os.path.expanduser("~/.swml/config.json"),
+            "/etc/swml/config.json"
+        ]
+    
+    def _load_config(self) -> None:
+        """Load configuration from the first available config file."""
+        for path in self.config_paths:
+            if os.path.exists(path):
+                try:
+                    with open(path, 'r') as f:
+                        self._config = json.load(f)
+                        self._config_file = path
+                        logger.info("config_loaded", path=path)
+                        break
+                except Exception as e:
+                    logger.error("config_load_error", path=path, error=str(e))
+    
+    def has_config(self) -> bool:
+        """Check if a configuration was loaded."""
+        return self._config is not None
+    
+    def get_config_file(self) -> Optional[str]:
+        """Get the path of the loaded config file."""
+        return self._config_file
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Get the raw configuration (before substitution)."""
+        return self._config or {}
+    
+    def substitute_vars(self, value: Any) -> Any:
+        """
+        Recursively substitute environment variables in configuration values.
+        
+        Supports ${VAR|default} syntax where:
+        - VAR is the environment variable name
+        - default is the fallback value if VAR is not set
+        
+        Args:
+            value: The value to process (can be string, dict, list, etc.)
+            
+        Returns:
+            The value with all environment variables substituted
+        """
+        if isinstance(value, str):
+            # Pattern to match ${VAR} or ${VAR|default}
+            pattern = r'\$\{([^}|]+)(?:\|([^}]*))?\}'
+            
+            def replacer(match):
+                var_name = match.group(1)
+                default = match.group(2) if match.group(2) is not None else ''
+                return os.environ.get(var_name, default)
+            
+            # Substitute all variables
+            result = re.sub(pattern, replacer, value)
+            
+            # Try to parse as JSON to get proper types
+            if result.lower() in ('true', 'false'):
+                return result.lower() == 'true'
+            elif result.isdigit():
+                return int(result)
+            elif result.replace('.', '', 1).isdigit():
+                return float(result)
+            else:
+                return result
+                
+        elif isinstance(value, dict):
+            # Recursively process dictionary
+            return {k: self.substitute_vars(v) for k, v in value.items()}
+            
+        elif isinstance(value, list):
+            # Recursively process list
+            return [self.substitute_vars(item) for item in value]
+            
+        else:
+            # Return other types as-is
+            return value
+    
+    def get(self, key_path: str, default: Any = None) -> Any:
+        """
+        Get a configuration value by dot-notation path.
+        
+        Args:
+            key_path: Dot-separated path (e.g., "security.ssl_enabled")
+            default: Default value if path not found
+            
+        Returns:
+            The configuration value with variables substituted
+        """
+        if not self._config:
+            return default
+            
+        # Navigate through the config using the dot path
+        keys = key_path.split('.')
+        value = self._config
+        
+        for key in keys:
+            if isinstance(value, dict) and key in value:
+                value = value[key]
+            else:
+                return default
+        
+        # Substitute variables before returning
+        return self.substitute_vars(value)
+    
+    def get_section(self, section: str) -> Dict[str, Any]:
+        """
+        Get an entire configuration section.
+        
+        Args:
+            section: The section name (e.g., "security", "server")
+            
+        Returns:
+            The configuration section with all variables substituted
+        """
+        if not self._config or section not in self._config:
+            return {}
+            
+        return self.substitute_vars(self._config[section])
+    
+    def merge_with_env(self, env_prefix: str = "SWML_") -> Dict[str, Any]:
+        """
+        Merge configuration with environment variables.
+        
+        Config file takes precedence over environment variables,
+        but config can reference env vars via substitution.
+        
+        Args:
+            env_prefix: Prefix for environment variables to consider
+            
+        Returns:
+            Merged configuration dictionary
+        """
+        # Start with substituted config
+        result = self.substitute_vars(self._config) if self._config else {}
+        
+        # Only add env vars that aren't already in config
+        # This preserves config file precedence
+        for key, value in os.environ.items():
+            if key.startswith(env_prefix):
+                # Convert SWML_SSL_ENABLED to ssl_enabled
+                config_key = key[len(env_prefix):].lower()
+                
+                # Only set if not already in config
+                if not self._has_nested_key(result, config_key):
+                    self._set_nested_key(result, config_key, value)
+        
+        return result
+    
+    def _has_nested_key(self, data: Dict, key_path: str) -> bool:
+        """Check if a nested key exists in dictionary."""
+        keys = key_path.split('_')
+        current = data
+        
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return False
+        return True
+    
+    def _set_nested_key(self, data: Dict, key_path: str, value: Any) -> None:
+        """Set a value in dictionary using underscore-separated path."""
+        keys = key_path.split('_')
+        current = data
+        
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            current = current[key]
+            
+        current[keys[-1]] = value
+    
+    @staticmethod
+    def find_config_file(service_name: Optional[str] = None, 
+                        additional_paths: Optional[List[str]] = None) -> Optional[str]:
+        """
+        Static method to find a config file for a service.
+        
+        Args:
+            service_name: Optional service name for service-specific config
+            additional_paths: Additional paths to check
+            
+        Returns:
+            Path to the first config file found, or None
+        """
+        paths = []
+        
+        # Service-specific config
+        if service_name:
+            paths.extend([
+                f"{service_name}_config.json",
+                f".swml/{service_name}_config.json"
+            ])
+        
+        # Additional paths
+        if additional_paths:
+            paths.extend(additional_paths)
+        
+        # Default paths
+        paths.extend([
+            "config.json",
+            "agent_config.json",
+            ".swml/config.json",
+            os.path.expanduser("~/.swml/config.json"),
+            "/etc/swml/config.json"
+        ])
+        
+        for path in paths:
+            if os.path.exists(path):
+                return path
+                
+        return None

{signalwire_agents-0.1.28 → signalwire_agents-0.1.29}/signalwire_agents/core/contexts.py

@@ -259,6 +259,10 @@ class Context:
         # Context prompt (separate from system_prompt)
         self._prompt_text: Optional[str] = None
         self._prompt_sections: List[Dict[str, Any]] = []
+        
+        # Context fillers
+        self._enter_fillers: Optional[Dict[str, List[str]]] = None
+        self._exit_fillers: Optional[Dict[str, List[str]]] = None
     
     def add_step(self, name: str) -> Step:
         """
@@ -450,6 +454,70 @@ class Context:
         self._prompt_sections.append({"title": title, "bullets": bullets})
         return self
     
+    def set_enter_fillers(self, enter_fillers: Dict[str, List[str]]) -> 'Context':
+        """
+        Set fillers that the AI says when entering this context
+        
+        Args:
+            enter_fillers: Dictionary mapping language codes (or "default") to lists of filler phrases
+                          Example: {"en-US": ["Welcome...", "Hello..."], "default": ["Entering..."]}
+            
+        Returns:
+            Self for method chaining
+        """
+        if enter_fillers and isinstance(enter_fillers, dict):
+            self._enter_fillers = enter_fillers
+        return self
+    
+    def set_exit_fillers(self, exit_fillers: Dict[str, List[str]]) -> 'Context':
+        """
+        Set fillers that the AI says when exiting this context
+        
+        Args:
+            exit_fillers: Dictionary mapping language codes (or "default") to lists of filler phrases
+                         Example: {"en-US": ["Goodbye...", "Thank you..."], "default": ["Exiting..."]}
+            
+        Returns:
+            Self for method chaining
+        """
+        if exit_fillers and isinstance(exit_fillers, dict):
+            self._exit_fillers = exit_fillers
+        return self
+    
+    def add_enter_filler(self, language_code: str, fillers: List[str]) -> 'Context':
+        """
+        Add enter fillers for a specific language
+        
+        Args:
+            language_code: Language code (e.g., "en-US", "es") or "default" for catch-all
+            fillers: List of filler phrases for entering this context
+            
+        Returns:
+            Self for method chaining
+        """
+        if language_code and fillers and isinstance(fillers, list):
+            if self._enter_fillers is None:
+                self._enter_fillers = {}
+            self._enter_fillers[language_code] = fillers
+        return self
+    
+    def add_exit_filler(self, language_code: str, fillers: List[str]) -> 'Context':
+        """
+        Add exit fillers for a specific language
+        
+        Args:
+            language_code: Language code (e.g., "en-US", "es") or "default" for catch-all
+            fillers: List of filler phrases for exiting this context
+            
+        Returns:
+            Self for method chaining
+        """
+        if language_code and fillers and isinstance(fillers, list):
+            if self._exit_fillers is None:
+                self._exit_fillers = {}
+            self._exit_fillers[language_code] = fillers
+        return self
+    
     def _render_prompt(self) -> Optional[str]:
         """Render the context's prompt text"""
         if self._prompt_text is not None:
@@ -533,6 +601,13 @@ class Context:
         elif self._prompt_text is not None:
             # Use string format
             context_dict["prompt"] = self._prompt_text
+        
+        # Add enter and exit fillers if defined
+        if self._enter_fillers is not None:
+            context_dict["enter_fillers"] = self._enter_fillers
+        
+        if self._exit_fillers is not None:
+            context_dict["exit_fillers"] = self._exit_fillers
             
         return context_dict