signalwire-agents 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

signalwire_agents/__init__.py

@@ -18,13 +18,12 @@ 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.27"
+__version__ = "0.1.29"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase
 from .core.contexts import ContextBuilder, Context, Step, create_simple_context
 from .core.data_map import DataMap, create_simple_api_tool, create_expression_tool
-from .core.state import StateManager, FileStateManager
 from signalwire_agents.agent_server import AgentServer
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_builder import SWMLBuilder
@@ -68,8 +67,6 @@ __all__ = [
     "AgentServer", 
     "SWMLService",
     "SWMLBuilder",
-    "StateManager",
-    "FileStateManager",
     "SwaigFunctionResult",
     "SWAIGFunction",
     "DataMap",

signalwire_agents/cli/config.py

@@ -41,12 +41,22 @@ ERROR_FUNCTION_NOT_FOUND = "Function '{function_name}' not found in agent"
 ERROR_CGI_HOST_REQUIRED = "CGI simulation requires --cgi-host"
 
 # Help messages
-HELP_DESCRIPTION = "Test SWAIG functions and generate SWML documents for SignalWire AI agents"
+HELP_DESCRIPTION = """Test SWAIG functions and generate SWML documents for SignalWire AI agents
+
+IMPORTANT: When using --exec, ALL options (like --call-id, --verbose, etc.) must come BEFORE --exec.
+Everything after --exec <function_name> is treated as arguments to the function."""
+
 HELP_EPILOG_SHORT = """
 examples:
   # Execute a function
   %(prog)s agent.py --exec search --query "test" --limit 5
   
+  # Execute with persistent session (--call-id MUST come BEFORE --exec)
+  %(prog)s agent.py --call-id my-session --exec add_todo --text "Buy milk"
+  
+  # WRONG: This won't work! --call-id is treated as a function argument
+  %(prog)s agent.py --exec add_todo --text "Buy milk" --call-id my-session
+  
   # Generate SWML
   %(prog)s agent.py --dump-swml --raw | jq '.'
   

signalwire_agents/cli/simulation/data_overrides.py

@@ -120,8 +120,12 @@ def apply_convenience_mappings(data: Dict[str, Any], args: argparse.Namespace) -
     
     # Map high-level arguments to specific paths
     if hasattr(args, 'call_id') and args.call_id:
-        set_nested_value(data, "call.call_id", args.call_id)
-        set_nested_value(data, "call.tag", args.call_id)  # tag often matches call_id
+        # Set at root level for SWAIG functions
+        data["call_id"] = args.call_id
+        # Also set in call object if it exists
+        if "call" in data:
+            set_nested_value(data, "call.call_id", args.call_id)
+            set_nested_value(data, "call.tag", args.call_id)  # tag often matches call_id
     
     if hasattr(args, 'project_id') and args.project_id:
         set_nested_value(data, "call.project_id", args.project_id)

signalwire_agents/cli/test_swaig.py

@@ -727,6 +727,12 @@ def main():
                     # Default behavior - minimal data
                     post_data = generate_minimal_post_data(args.tool_name, function_args)
                 
+                # Apply convenience mappings from CLI args (e.g., --call-id)
+                post_data = apply_convenience_mappings(post_data, args)
+                
+                # Apply explicit overrides
+                post_data = apply_overrides(post_data, args.override, args.override_json)
+                
                 if args.verbose:
                     print(f"Post data: {json.dumps(post_data, indent=2)}")
                     print("-" * 60)

signalwire_agents/core/agent_base.py

@@ -49,7 +49,6 @@ from signalwire_agents.core.swaig_function import SWAIGFunction
 from signalwire_agents.core.function_result import SwaigFunctionResult
 from signalwire_agents.core.swml_renderer import SwmlRenderer
 from signalwire_agents.core.security.session_manager import SessionManager
-from signalwire_agents.core.state import StateManager, FileStateManager
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_handler import AIVerbHandler
 from signalwire_agents.core.skill_manager import SkillManager
@@ -113,13 +112,11 @@ class AgentBase(
         port: int = 3000,
         basic_auth: Optional[Tuple[str, str]] = None,
         use_pom: bool = True,
-        enable_state_tracking: bool = False,
         token_expiry_secs: int = 3600,
         auto_answer: bool = True,
         record_call: bool = False,
         record_format: str = "mp4",
         record_stereo: bool = True,
-        state_manager: Optional[StateManager] = None,
         default_webhook_url: Optional[str] = None,
         agent_id: Optional[str] = None,
         native_functions: Optional[List[str]] = None,
@@ -138,13 +135,11 @@ class AgentBase(
             port: Port to bind the web server to
             basic_auth: Optional (username, password) tuple for basic auth
             use_pom: Whether to use POM for prompt building
-            enable_state_tracking: Whether to register startup_hook and hangup_hook SWAIG functions to track conversation state
             token_expiry_secs: Seconds until tokens expire
             auto_answer: Whether to automatically answer calls
             record_call: Whether to record calls
             record_format: Recording format
             record_stereo: Whether to record in stereo
-            state_manager: Optional state manager for this agent
             default_webhook_url: Optional default webhook URL for all SWAIG functions
             agent_id: Optional unique ID for this agent, generated if not provided
             native_functions: Optional list of native functions to include in the SWAIG object
@@ -207,7 +202,6 @@ class AgentBase(
         
         # Initialize session manager
         self._session_manager = SessionManager(token_expiry_secs=token_expiry_secs)
-        self._enable_state_tracking = enable_state_tracking
         
         # URL override variables
         self._web_hook_url_override = None
@@ -229,8 +223,6 @@ class AgentBase(
         # Process declarative PROMPT_SECTIONS if defined in subclass
         self._process_prompt_sections()
         
-        # Initialize state manager
-        self._state_manager = state_manager or FileStateManager()
         
         # Process class-decorated tools (using @AgentBase.tool)
         self._tool_registry.register_class_decorated_tools()
@@ -238,9 +230,6 @@ class AgentBase(
         # Add native_functions parameter
         self.native_functions = native_functions or []
         
-        # Register state tracking tools if enabled
-        if enable_state_tracking:
-            self._register_state_tracking_tools()
         
         # Initialize new configuration containers
         self._hints = []
@@ -581,7 +570,7 @@ class AgentBase(
         post_prompt = agent_to_use.get_post_prompt()
         
         # Generate a call ID if needed
-        if agent_to_use._enable_state_tracking and call_id is None:
+        if call_id is None:
             call_id = agent_to_use._session_manager.create_session()
             
         # Start with any SWAIG query params that were set

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/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