signalwire-agents 0.1.13__py3-none-any.whl → 1.0.17.dev4__py3-none-any.whl

signalwire_agents/core/swml_service.py

@@ -24,51 +24,11 @@ import types
 from typing import Dict, List, Any, Optional, Union, Callable, Tuple, Type
 from urllib.parse import urlparse
 
-# Import and configure structlog
-try:
-    import structlog
-    
-    # Only configure if not already configured
-    if not hasattr(structlog, "_configured") or not structlog._configured:
-        structlog.configure(
-            processors=[
-                structlog.stdlib.filter_by_level,
-                structlog.stdlib.add_logger_name,
-                structlog.stdlib.add_log_level,
-                structlog.stdlib.PositionalArgumentsFormatter(),
-                structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
-                structlog.processors.StackInfoRenderer(),
-                structlog.processors.format_exc_info,
-                structlog.processors.UnicodeDecoder(),
-                structlog.dev.ConsoleRenderer()
-            ],
-            context_class=dict,
-            logger_factory=structlog.stdlib.LoggerFactory(),
-            wrapper_class=structlog.stdlib.BoundLogger,
-            cache_logger_on_first_use=True,
-        )
-        
-        # Set up root logger with structlog
-        logging.basicConfig(
-            format="%(message)s",
-            stream=sys.stdout,
-            level=logging.INFO,
-        )
-        
-        # Mark as configured to avoid duplicate configuration
-        structlog._configured = True
-    
-    # Create the module logger
-    logger = structlog.get_logger("swml_service")
-    
-except ImportError:
-    # Fallback to standard logging if structlog is not available
-    logging.basicConfig(
-        level=logging.INFO,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-        stream=sys.stdout
-    )
-    logger = logging.getLogger("swml_service")
+# Import centralized logging system
+from signalwire_agents.core.logging_config import get_logger
+
+# Create the module logger using centralized system
+logger = get_logger("swml_service")
 
 try:
     import fastapi
@@ -82,6 +42,7 @@ except ImportError:
 
 from signalwire_agents.utils.schema_utils import SchemaUtils
 from signalwire_agents.core.swml_handler import VerbHandlerRegistry, SWMLVerbHandler
+from signalwire_agents.core.security_config import SecurityConfig
 
 
 class SWMLService:
@@ -103,9 +64,10 @@ class SWMLService:
         name: str,
         route: str = "/",
         host: str = "0.0.0.0",
-        port: int = 3000,
+        port: Optional[int] = None,
         basic_auth: Optional[Tuple[str, str]] = None,
-        schema_path: Optional[str] = None
+        schema_path: Optional[str] = None,
+        config_file: Optional[str] = None
     ):
         """
         Initialize a new SWML service
@@ -117,40 +79,44 @@ class SWMLService:
             port: Port to bind the web server to
             basic_auth: Optional (username, password) tuple for basic auth
             schema_path: Optional path to the schema file
+            config_file: Optional path to configuration file
         """
         self.name = name
         self.route = route.rstrip("/")  # Ensure no trailing slash
         self.host = host
-        self.port = port
-        self.ssl_enabled = False
-        self.domain = None
+        # Use provided port, or PORT env var, or default to 3000
+        self.port = port if port is not None else int(os.environ.get("PORT", 3000))
+        
+        # Initialize logger for this instance FIRST before using it
+        self.log = logger.bind(service=name)
+        
+        # Load unified security configuration with optional config file
+        self.security = SecurityConfig(config_file=config_file, service_name=name)
+        self.security.log_config("SWMLService")
+        
+        # For backward compatibility, expose SSL settings as instance attributes
+        self.ssl_enabled = self.security.ssl_enabled
+        self.domain = self.security.domain
+        self.ssl_cert_path = self.security.ssl_cert_path
+        self.ssl_key_path = self.security.ssl_key_path
         
         # Initialize proxy detection attributes
         self._proxy_url_base = os.environ.get('SWML_PROXY_URL_BASE')
+        self._proxy_url_base_from_env = bool(self._proxy_url_base)  # Track if it came from environment
+        if self._proxy_url_base:
+            self.log.warning("SWML_PROXY_URL_BASE is set in environment - This overrides SSL configuration and port settings. Remove this variable to use automatic detection.", 
+                           proxy_url_base=self._proxy_url_base)
         self._proxy_detection_done = False
         self._proxy_debug = os.environ.get('SWML_PROXY_DEBUG', '').lower() in ('true', '1', 'yes')
-        
-        # Initialize logger for this instance
-        self.log = logger.bind(service=name)
-        self.log.info("service_initializing", route=self.route, host=host, port=port)
+        self.log.info("service_initializing", route=self.route, host=self.host, port=self.port)
         
         # Set basic auth credentials
         if basic_auth is not None:
             # Use provided credentials
             self._basic_auth = basic_auth
         else:
-            # Check environment variables first
-            env_user = os.environ.get('SWML_BASIC_AUTH_USER')
-            env_pass = os.environ.get('SWML_BASIC_AUTH_PASSWORD')
-            
-            if env_user and env_pass:
-                # Use environment variables
-                self._basic_auth = (env_user, env_pass)
-            else:
-                # Generate random credentials as fallback
-                username = f"user_{secrets.token_hex(4)}"
-                password = secrets.token_urlsafe(16)
-                self._basic_auth = (username, password)
+            # Use unified security config for auth credentials
+            self._basic_auth = self.security.get_basic_auth()
         
         # Find the schema file if not provided
         if schema_path is None:
@@ -687,10 +653,8 @@ class SWMLService:
         Returns:
             Response with SWML document or error
         """
-        # Auto-detect proxy on first request if not explicitly configured
-        if not self._proxy_detection_done and not self._proxy_url_base:
-            self._detect_proxy_from_request(request)
-            self._proxy_detection_done = True
+        # Always detect proxy from current request - allows mixing direct and proxied access
+        self._detect_proxy_from_request(request)
             
         # Check auth
         if not self._check_basic_auth(request):
@@ -789,21 +753,21 @@ class SWMLService:
         """
         import uvicorn
         
-        # Store SSL configuration
-        self.ssl_enabled = ssl_enabled if ssl_enabled is not None else False
-        self.domain = domain
+        # Store SSL configuration (override environment if explicitly provided)
+        if ssl_enabled is not None:
+            self.ssl_enabled = ssl_enabled
+        if domain is not None:
+            self.domain = domain
         
-        # Set SSL paths
-        ssl_cert_path = ssl_cert
-        ssl_key_path = ssl_key
+        # Set SSL paths (use provided paths or fall back to environment)
+        ssl_cert_path = ssl_cert or getattr(self, 'ssl_cert_path', None)
+        ssl_key_path = ssl_key or getattr(self, 'ssl_key_path', None)
         
         # Validate SSL configuration if enabled
         if self.ssl_enabled:
-            if not ssl_cert_path or not os.path.exists(ssl_cert_path):
-                self.log.warning("ssl_cert_not_found", path=ssl_cert_path)
-                self.ssl_enabled = False
-            elif not ssl_key_path or not os.path.exists(ssl_key_path):
-                self.log.warning("ssl_key_not_found", path=ssl_key_path)
+            is_valid, error = self.security.validate_ssl_config()
+            if not is_valid:
+                self.log.warning("ssl_config_invalid", error=error)
                 self.ssl_enabled = False
             elif not self.domain:
                 self.log.warning("ssl_domain_not_specified")
@@ -818,8 +782,11 @@ class SWMLService:
             # This avoids the FastAPI error about prefixes ending with slashes
             normalized_route = "/" + self.route.strip("/")
             
-            # Include router with the normalized prefix
-            app.include_router(router, prefix=normalized_route)
+            # Include router with the normalized prefix (handle root route special case)
+            if normalized_route == "/":
+                app.include_router(router)
+            else:
+                app.include_router(router, prefix=normalized_route)
             
             # Add a catch-all route handler that will handle both /path and /path/ formats
             # This provides the same behavior without using a trailing slash in the prefix
@@ -876,27 +843,27 @@ class SWMLService:
         # Get the auth credentials
         username, password = self._basic_auth
         
-        # Use correct protocol and host in displayed URL
-        protocol = "https" if self.ssl_enabled else "http"
-        display_host = self.domain if self.ssl_enabled and self.domain else f"{host}:{port}"
+        # Get the proper URL using unified URL building
+        startup_url = self._build_full_url(include_auth=False)
         
         self.log.info("starting_server", 
-                     url=f"{protocol}://{display_host}{self.route}",
+                     url=startup_url,
                      ssl_enabled=self.ssl_enabled,
                      username=username,
                      password_length=len(password))
         
         # Print user-friendly startup message (keep for UX)
         print(f"Service '{self.name}' is available at:")
-        print(f"URL: {protocol}://{display_host}{self.route}")
-        print(f"URL with trailing slash: {protocol}://{display_host}{self.route}/")
+        print(f"URL: {startup_url}")
+        print(f"URL with trailing slash: {startup_url}/")
         print(f"Basic Auth: {username}:{password}")
         
         # Check if SIP routing is enabled and log additional info
         if self._routing_callbacks:
             print(f"Callback endpoints:")
             for path in self._routing_callbacks:
-                print(f"{protocol}://{display_host}{self.route}{path}")
+                callback_url = self._build_full_url(endpoint=path.lstrip('/'), include_auth=False)
+                print(f"  {callback_url}")
         
         # Start uvicorn with or without SSL
         if self.ssl_enabled and ssl_cert_path and ssl_key_path:
@@ -972,149 +939,146 @@ class SWMLService:
         
         return username, password
     
-    # Keep the existing methods for backward compatibility
-    
-    def add_answer_verb(self, max_duration: Optional[int] = None, codecs: Optional[str] = None) -> bool:
-        """
-        Add an answer verb to the current document
         
-        Args:
-            max_duration: Maximum duration in seconds
-            codecs: Comma-separated list of codecs
-            
-        Returns:
-            True if added successfully, False otherwise
+    def _get_base_url(self, include_auth: bool = True) -> str:
         """
-        config = {}
-        if max_duration is not None:
-            config["max_duration"] = max_duration
-        if codecs is not None:
-            config["codecs"] = codecs
-            
-        return self.add_verb("answer", config)
-    
-    def add_hangup_verb(self, reason: Optional[str] = None) -> bool:
-        """
-        Add a hangup verb to the current document
+        Get the base URL for this service, using proxy info if available or falling back to configured values
+        
+        This is the central method for URL building that handles both startup configuration
+        and per-request proxy detection.
         
         Args:
-            reason: Hangup reason (hangup, busy, decline)
+            include_auth: Whether to include authentication credentials in the URL
             
         Returns:
-            True if added successfully, False otherwise
+            Base URL string (protocol://[auth@]host[:port])
         """
-        config = {}
-        if reason is not None:
-            config["reason"] = reason
+        # Debug logging to understand state
+        self.log.debug("_get_base_url called",
+                      has_proxy_url_base=hasattr(self, '_proxy_url_base'),
+                      proxy_url_base=getattr(self, '_proxy_url_base', None),
+                      proxy_url_base_from_env=getattr(self, '_proxy_url_base_from_env', False),
+                      env_var=os.environ.get('SWML_PROXY_URL_BASE'),
+                      include_auth=include_auth,
+                      caller=inspect.stack()[1].function if len(inspect.stack()) > 1 else "unknown")
+        
+        # Check if we have proxy information from a request
+        if hasattr(self, '_proxy_url_base') and self._proxy_url_base:
+            base = self._proxy_url_base.rstrip('/')
+            self.log.debug("Using proxy URL base", proxy_url_base=base)
+
+            # Add auth credentials if requested
+            if include_auth:
+                username, password = self._basic_auth
+                url = urlparse(base)
+                base = url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
             
-        return self.add_verb("hangup", config)
-    
-    def add_ai_verb(self, 
-               prompt_text: Optional[str] = None,
-               prompt_pom: Optional[List[Dict[str, Any]]] = None,
-               post_prompt: Optional[str] = None,
-               post_prompt_url: Optional[str] = None,
-               swaig: Optional[Dict[str, Any]] = None,
-               **kwargs) -> bool:
-        """
-        Add an AI verb to the current document
+            return base
         
-        Args:
-            prompt_text: Simple prompt text
-            prompt_pom: Prompt object model
-            post_prompt: Post-prompt text
-            post_prompt_url: Post-prompt URL
-            swaig: SWAIG configuration
-            **kwargs: Additional parameters
-            
-        Returns:
-            True if added successfully, False otherwise
-        """
-        config = {}
+        # No proxy, use configured values
+        # Determine protocol based on SSL settings
+        protocol = "https" if self.ssl_enabled else "http"
         
-        # Handle prompt
-        if prompt_text is not None:
-            config["prompt"] = prompt_text
-        elif prompt_pom is not None:
-            config["prompt"] = prompt_pom
+        # Debug logging
+        self.log.debug("_get_base_url",
+                      ssl_enabled=self.ssl_enabled,
+                      domain=self.domain,
+                      port=self.port,
+                      protocol=protocol)
+        
+        # Determine host part
+        if self.ssl_enabled and self.domain:
+            # Use domain for SSL
+            if protocol == "https" and self.port == 443:
+                host_part = self.domain  # Don't include port for standard HTTPS
+            elif protocol == "http" and self.port == 80:
+                host_part = self.domain  # Don't include port for standard HTTP
+            else:
+                host_part = f"{self.domain}:{self.port}"
+                self.log.debug("Using domain with port", domain=self.domain, port=self.port, host_part=host_part)
+        else:
+            # Use configured host
+            if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
+                host = "localhost"
+            else:
+                host = self.host
             
-        # Handle post prompt
-        if post_prompt is not None:
-            config["post_prompt"] = post_prompt
+            # Include port unless it's the standard port for the protocol
+            if (protocol == "https" and self.port == 443) or (protocol == "http" and self.port == 80):
+                host_part = host
+            else:
+                host_part = f"{host}:{self.port}"
         
-        # Handle post prompt URL
-        if post_prompt_url is not None:
-            config["post_prompt_url"] = post_prompt_url
-            
-        # Handle SWAIG
-        if swaig is not None:
-            config["SWAIG"] = swaig
-            
-        # Handle additional parameters
-        for key, value in kwargs.items():
-            if value is not None:
-                config[key] = value
-                
-        return self.add_verb("ai", config)
+        # Build base URL
+        if include_auth:
+            username, password = self._basic_auth
+            base = f"{protocol}://{username}:{password}@{host_part}"
+        else:
+            base = f"{protocol}://{host_part}"
         
-    def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
+        return base
+    
+    def _build_full_url(self, endpoint: str = "", include_auth: bool = True, query_params: Optional[Dict[str, str]] = None) -> str:
         """
-        Helper method to build webhook URLs consistently
+        Build the full URL for this service or a specific endpoint
+        
+        This is the internal implementation used by both get_full_url (for AgentBase compatibility)
+        and _build_webhook_url.
         
         Args:
-            endpoint: The endpoint path (e.g., "swaig", "post_prompt")
+            endpoint: Optional endpoint path (e.g., "swaig", "post_prompt")
+            include_auth: Whether to include authentication credentials in the URL
             query_params: Optional query parameters to append
             
         Returns:
-            Fully constructed webhook URL
+            Full URL string
         """
-        # Base URL construction
-        if hasattr(self, '_proxy_url_base') and getattr(self, '_proxy_url_base', None):
-            # For proxy URLs
-            base = self._proxy_url_base.rstrip('/')
-            
-            # Always add auth credentials
-            username, password = self._basic_auth
-            url = urlparse(base)
-            base = url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
+        # Get base URL using central method
+        base = self._get_base_url(include_auth=include_auth)
+
+        # Build path
+        if endpoint:
+            # Ensure endpoint doesn't start with slash
+            endpoint = endpoint.lstrip('/')
+            # Add trailing slash to endpoint to prevent redirects
+            if not endpoint.endswith('/'):
+                endpoint = f"{endpoint}/"
+            path = f"{self.route}/{endpoint}"
         else:
-            # Determine protocol based on SSL settings
-            protocol = "https" if getattr(self, 'ssl_enabled', False) else "http"
-            
-            # Use domain if available and SSL is enabled
-            if getattr(self, 'ssl_enabled', False) and getattr(self, 'domain', None):
-                host_part = self.domain
-            else:
-                # For local URLs
-                if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
-                    host = "localhost"
-                else:
-                    host = self.host
-                
-                host_part = f"{host}:{self.port}"
-                
-            # Always include auth credentials
-            username, password = self._basic_auth
-            base = f"{protocol}://{username}:{password}@{host_part}"
+            # Just the route itself
+            path = self.route if self.route != "/" else ""
         
-        # Ensure the endpoint has a trailing slash to prevent redirects
-        if endpoint and not endpoint.endswith('/'):
-            endpoint = f"{endpoint}/"
-            
-        # Simple path - use the route directly with the endpoint
-        path = f"{self.route}/{endpoint}"
-            
         # Construct full URL
         url = f"{base}{path}"
         
-        # Add query parameters if any (only if they have values)
+        # Add query parameters if any
         if query_params:
             filtered_params = {k: v for k, v in query_params.items() if v}
             if filtered_params:
                 params = "&".join([f"{k}={v}" for k, v in filtered_params.items()])
                 url = f"{url}?{params}"
+        
+        return url
+    
+    def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
+        """
+        Helper method to build webhook URLs consistently
+        
+        Args:
+            endpoint: The endpoint path (e.g., "swaig", "post_prompt")
+            query_params: Optional query parameters to append
             
-        return url 
+        Returns:
+            Fully constructed webhook URL
+        """
+        self.log.debug("_build_webhook_url called",
+                      endpoint=endpoint,
+                      query_params=query_params,
+                      proxy_url_base=getattr(self, '_proxy_url_base', None),
+                      proxy_url_base_from_env=getattr(self, '_proxy_url_base_from_env', False))
+        
+        # Use the central URL building method
+        return self._build_full_url(endpoint=endpoint, include_auth=True, query_params=query_params) 
 
     def _detect_proxy_from_request(self, request: Request) -> None:
         """
@@ -1124,6 +1088,10 @@ class SWMLService:
         Args:
             request: FastAPI Request object
         """
+        # If SWML_PROXY_URL_BASE was already set (e.g., from environment), don't override it
+        if self._proxy_url_base:
+            return
+            
         # First check for standard X-Forwarded headers (used by most proxies including ngrok)
         forwarded_host = request.headers.get("X-Forwarded-Host")
         forwarded_proto = request.headers.get("X-Forwarded-Proto", "http")
@@ -1208,4 +1176,4 @@ class SWMLService:
         if proxy_url:
             self._proxy_url_base = proxy_url.rstrip('/')
             self.log.info("proxy_url_manually_set", proxy_url_base=self._proxy_url_base)
-            self._proxy_detection_done = True 
+            self._proxy_detection_done = True 

signalwire_agents/mcp_gateway/__init__.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+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.
+"""
+
+"""
+MCP-SWAIG Gateway Package
+
+HTTP/HTTPS server that bridges MCP servers with SignalWire SWAIG functions.
+"""
+
+from .gateway_service import MCPGateway, main
+from .session_manager import Session, SessionManager
+from .mcp_manager import MCPService, MCPClient, MCPManager
+
+__all__ = [
+    'MCPGateway',
+    'main',
+    'Session',
+    'SessionManager',
+    'MCPService',
+    'MCPClient',
+    'MCPManager',
+]