signalwire-agents 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

signalwire_agents/core/skill_manager.py

@@ -182,4 +182,6 @@ class SkillManager:
         if skill_identifier in self.loaded_skills:
             return self.loaded_skills[skill_identifier]
         
-        return None 
+        return None
+    
+ 

signalwire_agents/core/swaig_function.py

@@ -31,6 +31,7 @@ class SWAIGFunction:
         secure: bool = False,
         fillers: Optional[Dict[str, List[str]]] = None,
         webhook_url: Optional[str] = None,
+        required: Optional[List[str]] = None,
         **extra_swaig_fields
     ):
         """
@@ -44,6 +45,7 @@ class SWAIGFunction:
             secure: Whether this function requires token validation
             fillers: Optional dictionary of filler phrases by language code
             webhook_url: Optional external webhook URL to use instead of local handling
+            required: Optional list of required parameter names
             **extra_swaig_fields: Additional SWAIG fields to include in function definition
         """
         self.name = name
@@ -53,6 +55,7 @@ class SWAIGFunction:
         self.secure = secure
         self.fillers = fillers
         self.webhook_url = webhook_url
+        self.required = required or []
         self.extra_swaig_fields = extra_swaig_fields
         
         # Mark as external if webhook_url is provided
@@ -73,11 +76,17 @@ class SWAIGFunction:
             return self.parameters
             
         # Otherwise, wrap the parameters in the expected structure
-        return {
+        result = {
             "type": "object",
             "properties": self.parameters
         }
         
+        # Add required fields if specified
+        if self.required:
+            result["required"] = self.required
+            
+        return result
+        
     def __call__(self, *args, **kwargs):
         """
         Call the underlying handler function

signalwire_agents/core/swml_service.py

@@ -90,13 +90,17 @@ class SWMLService:
         self.ssl_cert_path = os.environ.get('SWML_SSL_CERT_PATH')
         self.ssl_key_path = os.environ.get('SWML_SSL_KEY_PATH')
         
+        # Initialize logger for this instance FIRST before using it
+        self.log = logger.bind(service=name)
+        
         # 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
@@ -652,10 +656,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):
@@ -785,8 +787,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
@@ -843,34 +848,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"
-        
-        # Determine display host - include port unless it's the standard port for the protocol
-        if self.ssl_enabled and self.domain:
-            # Use domain, but include port if it's not the standard HTTPS port (443)
-            display_host = f"{self.domain}:{port}" if port != 443 else self.domain
-        else:
-            # Use host:port for HTTP or when no domain is specified
-            display_host = 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:
@@ -947,65 +945,145 @@ class SWMLService:
         return username, password
     
         
-    def _build_webhook_url(self, endpoint: str, query_params: Optional[Dict[str, str]] = None) -> str:
+    def _get_base_url(self, include_auth: bool = True) -> str:
         """
-        Helper method to build webhook URLs consistently
+        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:
-            endpoint: The endpoint path (e.g., "swaig", "post_prompt")
-            query_params: Optional query parameters to append
+            include_auth: Whether to include authentication credentials in the URL
             
         Returns:
-            Fully constructed webhook URL
+            Base URL string (protocol://[auth@]host[:port])
         """
-        # Base URL construction
-        if hasattr(self, '_proxy_url_base') and getattr(self, '_proxy_url_base', None):
-            # For proxy URLs
+        # 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()
             
-            # Always add auth credentials
-            username, password = self._basic_auth
-            url = urlparse(base)
-            base = url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
+            return base
+        
+        # No proxy, use configured values
+        # Determine protocol based on SSL settings
+        protocol = "https" if self.ssl_enabled else "http"
+        
+        # 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:
-            # Determine protocol based on SSL settings
-            protocol = "https" if getattr(self, 'ssl_enabled', False) else "http"
+            # Use configured host
+            if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
+                host = "localhost"
+            else:
+                host = self.host
             
-            # Use domain if available and SSL is enabled
-            if getattr(self, 'ssl_enabled', False) and getattr(self, 'domain', None):
-                # Use domain, but include port if it's not the standard HTTPS port (443)
-                host_part = f"{self.domain}:{self.port}" if self.port != 443 else self.domain
+            # 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:
-                # 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
+        
+        # Build base URL
+        if include_auth:
             username, password = self._basic_auth
             base = f"{protocol}://{username}:{password}@{host_part}"
+        else:
+            base = f"{protocol}://{host_part}"
         
-        # 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}"
+        return base
+    
+    def _build_full_url(self, endpoint: str = "", include_auth: bool = True, query_params: Optional[Dict[str, str]] = None) -> str:
+        """
+        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: 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:
+            Full URL string
+        """
+        # 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:
+            # Just the route itself
+            path = self.route if self.route != "/" else ""
+        
         # 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:
         """
@@ -1015,6 +1093,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")
@@ -1099,4 +1181,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