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

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

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

{signalwire_agents-0.1.27/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.27
+Version: 0.1.29
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT
@@ -593,64 +593,6 @@ if __name__ == "__main__":
     agent.serve(host="0.0.0.0", port=8000)
 ```
 
-## Using State Management
-
-```python
-from signalwire_agents import AgentBase
-from signalwire_agents.core.function_result import SwaigFunctionResult
-from signalwire_agents.core.state import FileStateManager
-
-class StatefulAgent(AgentBase):
-    def __init__(self):
-        # Configure state management
-        state_manager = FileStateManager(storage_dir="./state_data")
-        
-        super().__init__(
-            name="stateful", 
-            route="/stateful",
-            enable_state_tracking=True,  # Enable state tracking
-            state_manager=state_manager  # Use custom state manager
-        )
-        
-        # When enable_state_tracking=True, startup_hook and hangup_hook
-        # are automatically registered to track session lifecycle
-    
-    # Custom tool for accessing and updating state
-    @AgentBase.tool(
-        name="save_preference",
-        description="Save a user preference",
-        parameters={
-            "preference_name": {
-                "type": "string",
-                "description": "Name of the preference to save"
-            },
-            "preference_value": {
-                "type": "string",
-                "description": "Value of the preference"
-            }
-        }
-    )
-    def save_preference(self, args, raw_data):
-        # Get the call ID from the raw data
-        call_id = raw_data.get("call_id")
-        
-        if call_id:
-            # Get current state or empty dict if none exists
-            state = self.get_state(call_id) or {}
-            
-            # Update the state
-            preferences = state.get("preferences", {})
-            preferences[args.get("preference_name")] = args.get("preference_value")
-            state["preferences"] = preferences
-            
-            # Save the updated state
-            self.update_state(call_id, state)
-            
-            return SwaigFunctionResult("Preference saved successfully")
-        else:
-            return SwaigFunctionResult("Could not save preference: No call ID")
-```
-
 ## Using Prefab Agents
 
 ```python

{signalwire_agents-0.1.27 → signalwire_agents-0.1.29}/README.md

@@ -519,64 +519,6 @@ if __name__ == "__main__":
     agent.serve(host="0.0.0.0", port=8000)
 ```
 
-## Using State Management
-
-```python
-from signalwire_agents import AgentBase
-from signalwire_agents.core.function_result import SwaigFunctionResult
-from signalwire_agents.core.state import FileStateManager
-
-class StatefulAgent(AgentBase):
-    def __init__(self):
-        # Configure state management
-        state_manager = FileStateManager(storage_dir="./state_data")
-        
-        super().__init__(
-            name="stateful", 
-            route="/stateful",
-            enable_state_tracking=True,  # Enable state tracking
-            state_manager=state_manager  # Use custom state manager
-        )
-        
-        # When enable_state_tracking=True, startup_hook and hangup_hook
-        # are automatically registered to track session lifecycle
-    
-    # Custom tool for accessing and updating state
-    @AgentBase.tool(
-        name="save_preference",
-        description="Save a user preference",
-        parameters={
-            "preference_name": {
-                "type": "string",
-                "description": "Name of the preference to save"
-            },
-            "preference_value": {
-                "type": "string",
-                "description": "Value of the preference"
-            }
-        }
-    )
-    def save_preference(self, args, raw_data):
-        # Get the call ID from the raw data
-        call_id = raw_data.get("call_id")
-        
-        if call_id:
-            # Get current state or empty dict if none exists
-            state = self.get_state(call_id) or {}
-            
-            # Update the state
-            preferences = state.get("preferences", {})
-            preferences[args.get("preference_name")] = args.get("preference_value")
-            state["preferences"] = preferences
-            
-            # Save the updated state
-            self.update_state(call_id, state)
-            
-            return SwaigFunctionResult("Preference saved successfully")
-        else:
-            return SwaigFunctionResult("Could not save preference: No call ID")
-```
-
 ## Using Prefab Agents
 
 ```python

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

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

{signalwire_agents-0.1.27 → signalwire_agents-0.1.29}/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-0.1.27 → signalwire_agents-0.1.29}/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-0.1.27 → signalwire_agents-0.1.29}/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-0.1.27 → signalwire_agents-0.1.29}/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-0.1.27 → signalwire_agents-0.1.29}/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-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