signalwire-agents 0.1.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

signalwire_agents/core/swml_service.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python3
 """
 Copyright (c) 2025 SignalWire
 
@@ -7,11 +8,9 @@ Licensed under the MIT License.
 See LICENSE file in the project root for full license information.
 """
 
+# -*- coding: utf-8 -*-
 """
-SWMLService - Base class for SWML document creation and serving
-
-This class provides the foundation for creating and serving SWML documents.
-It handles schema validation, document creation, and web service functionality.
+Base SWML Service for SignalWire Agents
 """
 
 import os
@@ -25,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="iso"),
-                structlog.processors.StackInfoRenderer(),
-                structlog.processors.format_exc_info,
-                structlog.processors.UnicodeDecoder(),
-                structlog.processors.JSONRenderer()
-            ],
-            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
@@ -83,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:
@@ -106,7 +66,8 @@ class SWMLService:
         host: str = "0.0.0.0",
         port: int = 3000,
         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
@@ -118,21 +79,34 @@ 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
+        
+        # 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)
         
         # Set basic auth credentials
@@ -140,18 +114,8 @@ class SWMLService:
             # 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:
@@ -188,17 +152,21 @@ class SWMLService:
         """
         Create auto-vivified methods for all verbs at initialization time
         """
-        print("Creating auto-vivified methods for all verbs")
+        self.log.debug("creating_verb_methods")
         
         # Get all verb names from the schema
+        if not self.schema_utils:
+            self.log.warning("no_schema_utils_available")
+            return
+            
         verb_names = self.schema_utils.get_all_verb_names()
-        print(f"Found {len(verb_names)} verbs in schema")
+        self.log.debug("found_verbs_in_schema", count=len(verb_names))
         
         # Create a method for each verb
         for verb_name in verb_names:
             # Skip verbs that already have specific methods
             if hasattr(self, verb_name):
-                print(f"Skipping {verb_name} - already has a method")
+                self.log.debug("skipping_verb_has_method", verb=verb_name)
                 continue
             
             # Handle sleep verb specially since it takes an integer directly
@@ -210,7 +178,7 @@ class SWMLService:
                     Args:
                         duration: The amount of time to sleep in milliseconds
                     """
-                    print(f"Executing auto-vivified method for 'sleep'")
+                    self.log.debug("executing_sleep_verb", duration=duration)
                     # Sleep verb takes a direct integer parameter in SWML
                     if duration is not None:
                         return self_instance.add_verb("sleep", duration)
@@ -226,7 +194,7 @@ class SWMLService:
                 # Also cache it for later
                 self._verb_methods_cache[verb_name] = sleep_method
                 
-                print(f"Created special method for {verb_name}")
+                self.log.debug("created_special_method", verb=verb_name)
                 continue
                 
             # Generate the method implementation for normal verbs
@@ -235,7 +203,7 @@ class SWMLService:
                     """
                     Dynamically generated method for SWML verb
                     """
-                    print(f"Executing auto-vivified method for '{name}'")
+                    self.log.debug("executing_verb_method", verb=name, kwargs_count=len(kwargs))
                     config = {}
                     for key, value in kwargs.items():
                         if value is not None:
@@ -260,7 +228,7 @@ class SWMLService:
             # Also cache it for later
             self._verb_methods_cache[verb_name] = method
             
-            print(f"Created method for {verb_name}")
+            self.log.debug("created_verb_method", verb=verb_name)
     
     def __getattr__(self, name: str) -> Any:
         """
@@ -280,21 +248,26 @@ class SWMLService:
         Raises:
             AttributeError: If name is not a valid SWML verb
         """
-        print(f"DEBUG: __getattr__ called for '{name}'")
+        self.log.debug("getattr_called", attribute=name)
         
         # Simple version to match our test script
         # First check if this is a valid SWML verb
+        if not self.schema_utils:
+            msg = f"'{self.__class__.__name__}' object has no attribute '{name}' (no schema available)"
+            self.log.debug("getattr_no_schema", attribute=name)
+            raise AttributeError(msg)
+            
         verb_names = self.schema_utils.get_all_verb_names()
         
         if name in verb_names:
-            print(f"DEBUG: '{name}' is a valid verb")
+            self.log.debug("getattr_valid_verb", verb=name)
             
             # Check if we already have this method in the cache
             if not hasattr(self, '_verb_methods_cache'):
                 self._verb_methods_cache = {}
                 
             if name in self._verb_methods_cache:
-                print(f"DEBUG: Using cached method for '{name}'")
+                self.log.debug("getattr_cached_method", verb=name)
                 return types.MethodType(self._verb_methods_cache[name], self)
             
             # Handle sleep verb specially since it takes an integer directly
@@ -306,7 +279,7 @@ class SWMLService:
                     Args:
                         duration: The amount of time to sleep in milliseconds
                     """
-                    print(f"DEBUG: Executing auto-vivified method for 'sleep'")
+                    self.log.debug("executing_sleep_method", duration=duration)
                     # Sleep verb takes a direct integer parameter in SWML
                     if duration is not None:
                         return self_instance.add_verb("sleep", duration)
@@ -317,7 +290,7 @@ class SWMLService:
                         raise TypeError("sleep() missing required argument: 'duration'")
                 
                 # Cache the method for future use
-                print(f"DEBUG: Caching special method for '{name}'")
+                self.log.debug("caching_sleep_method", verb=name)
                 self._verb_methods_cache[name] = sleep_method
                 
                 # Return the bound method
@@ -328,7 +301,7 @@ class SWMLService:
                 """
                 Dynamically generated method for SWML verb
                 """
-                print(f"DEBUG: Executing auto-vivified method for '{name}'")
+                self.log.debug("executing_dynamic_verb", verb=name, kwargs_count=len(kwargs))
                 config = {}
                 for key, value in kwargs.items():
                     if value is not None:
@@ -343,7 +316,7 @@ class SWMLService:
                 verb_method.__doc__ = f"Add the {name} verb to the document."
             
             # Cache the method for future use
-            print(f"DEBUG: Caching method for '{name}'")
+            self.log.debug("caching_verb_method", verb=name)
             self._verb_methods_cache[name] = verb_method
             
             # Return the bound method
@@ -351,7 +324,7 @@ class SWMLService:
         
         # Not a valid verb
         msg = f"'{self.__class__.__name__}' object has no attribute '{name}'"
-        print(f"DEBUG: {msg}")
+        self.log.debug("getattr_invalid_attribute", attribute=name, error=msg)
         raise AttributeError(msg)
     
     def _find_schema_path(self) -> Optional[str]:
@@ -565,58 +538,41 @@ class SWMLService:
     
     def as_router(self) -> APIRouter:
         """
-        Get a FastAPI router for this service
+        Create a FastAPI router for this service
         
         Returns:
-            FastAPI router
+            APIRouter: FastAPI router
         """
-        router = APIRouter()
+        router = APIRouter(redirect_slashes=False)
         
-        # Root endpoint - without trailing slash
-        @router.get("")
-        @router.post("")
-        async def handle_root_no_slash(request: Request, response: Response):
-            """Handle GET/POST requests to the root endpoint"""
-            return await self._handle_request(request, response)
-            
-        # Root endpoint - with trailing slash
+        # Root endpoint with and without trailing slash
         @router.get("/")
         @router.post("/")
-        async def handle_root_with_slash(request: Request, response: Response):
-            """Handle GET/POST requests to the root endpoint with trailing slash"""
+        async def handle_root(request: Request, response: Response):
+            """Handle requests to the root endpoint"""
             return await self._handle_request(request, response)
         
-        # Add endpoints for all registered routing callbacks
+        # Register routing callbacks as needed
         if hasattr(self, '_routing_callbacks') and self._routing_callbacks:
             for callback_path, callback_fn in self._routing_callbacks.items():
-                # Skip the root path as it's already handled
+                # Skip the root path which is already handled
                 if callback_path == "/":
                     continue
                     
-                # Register the endpoint without trailing slash
-                @router.get(callback_path)
-                @router.post(callback_path)
-                async def handle_callback_no_slash(request: Request, response: Response, cb_path=callback_path):
-                    """Handle GET/POST requests to a registered callback path"""
-                    # Store the callback path in request state for _handle_request to use
+                # Register both versions: with and without trailing slash
+                path = callback_path.rstrip("/")
+                path_with_slash = f"{path}/"
+                
+                @router.get(path)
+                @router.get(path_with_slash)
+                @router.post(path)
+                @router.post(path_with_slash)
+                async def handle_callback(request: Request, response: Response, cb_path=callback_path):
+                    """Handle requests to callback endpoints"""
+                    # Store the callback path in the request state
                     request.state.callback_path = cb_path
                     return await self._handle_request(request, response)
-                    
-                # Register the endpoint with trailing slash if it doesn't already have one
-                if not callback_path.endswith('/'):
-                    slash_path = f"{callback_path}/"
-                    
-                    @router.get(slash_path)
-                    @router.post(slash_path)
-                    async def handle_callback_with_slash(request: Request, response: Response, cb_path=callback_path):
-                        """Handle GET/POST requests to a registered callback path with trailing slash"""
-                        # Store the callback path in request state for _handle_request to use
-                        request.state.callback_path = cb_path
-                        return await self._handle_request(request, response)
-                        
-                self.log.info("callback_endpoint_registered", path=callback_path)
         
-        self._router = router
         return router
     
     def register_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]], 
@@ -696,10 +652,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,64 +743,126 @@ class SWMLService:
         Start a web server for this service
         
         Args:
-            host: Optional host to override the default
-            port: Optional port to override the default
+            host: Host to bind to (defaults to self.host)
+            port: Port to bind to (defaults to self.port)
             ssl_cert: Path to SSL certificate file
-            ssl_key: Path to SSL private key file
-            ssl_enabled: Whether to enable SSL/HTTPS
-            domain: Domain name for the SSL certificate and external URLs
+            ssl_key: Path to SSL key file
+            ssl_enabled: Whether to enable SSL
+            domain: Domain name for SSL certificate
         """
         import uvicorn
         
-        # Determine SSL settings from parameters or environment variables
-        self.ssl_enabled = ssl_enabled if ssl_enabled is not None else os.environ.get('SWML_SSL_ENABLED', '').lower() in ('true', '1', 'yes')
-        ssl_cert_path = ssl_cert or os.environ.get('SWML_SSL_CERT_PATH', '')
-        ssl_key_path = ssl_key or os.environ.get('SWML_SSL_KEY_PATH', '')
-        self.domain = domain or os.environ.get('SWML_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 (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")
                 # We'll continue, but URLs might not be correctly generated
         
         if self._app is None:
-            app = FastAPI()
+            # Use redirect_slashes=False to be consistent with AgentBase
+            app = FastAPI(redirect_slashes=False)
             router = self.as_router()
-            app.include_router(router, prefix=self.route)
+            
+            # Normalize the route to ensure it starts with a slash and doesn't end with one
+            # This avoids the FastAPI error about prefixes ending with slashes
+            normalized_route = "/" + self.route.strip("/")
+            
+            # 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
+            @app.get("/{full_path:path}")
+            @app.post("/{full_path:path}")
+            async def handle_all_routes(request: Request, response: Response, full_path: str):
+                # Get our route path without leading slash for comparison
+                route_path = normalized_route.lstrip("/")
+                route_with_slash = route_path + "/"
+                
+                # Log the incoming path for debugging
+                self.log.debug("catch_all_route_hit", path=full_path, route=route_path)
+                
+                # Check for exact match to our route (without trailing slash)
+                if full_path == route_path:
+                    # This is our exact route - handle it directly
+                    return await self._handle_request(request, response)
+                    
+                # Check for our route with a trailing slash or subpaths
+                elif full_path == route_with_slash or full_path.startswith(route_with_slash):
+                    # This is our route with a trailing slash
+                    # Extract the path after our route prefix
+                    sub_path = full_path[len(route_with_slash):]
+                    
+                    # Forward to the appropriate handler in our router
+                    if not sub_path:
+                        # Root endpoint
+                        return await self._handle_request(request, response)
+                    
+                    # Check for routing callbacks if there are any
+                    if hasattr(self, '_routing_callbacks'):
+                        for callback_path, callback_fn in self._routing_callbacks.items():
+                            cb_path_clean = callback_path.strip("/")
+                            if sub_path == cb_path_clean or sub_path.startswith(cb_path_clean + "/"):
+                                # Store the callback path in request state for handlers to use
+                                request.state.callback_path = callback_path
+                                return await self._handle_request(request, response)
+                
+                # Not our route or not matching our patterns
+                self.log.debug("no_route_match", path=full_path)
+                return {"error": "Path not found"}
+            
+            # Log all routes for debugging
+            self.log.debug("registered_routes", service=self.name)
+            for route in app.routes:
+                if hasattr(route, "path"):
+                    self.log.debug("route_registered", path=route.path)
+            
             self._app = app
         
         host = host or self.host
         port = port or self.port
         
-        # Print the auth credentials
+        # 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: {startup_url}")
+        print(f"URL with trailing slash: {startup_url}/")
         print(f"Basic Auth: {username}:{password}")
         
-        # Check if SIP routing is enabled and print additional info
+        # 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}{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:
@@ -922,149 +938,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
-        """
-        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:
+    def _get_base_url(self, include_auth: bool = True) -> str:
         """
-        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:
         """
@@ -1074,6 +1087,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")
@@ -1158,4 +1175,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