signalwire-agents 1.0.8__tar.gz → 1.0.10__tar.gz

{signalwire_agents-1.0.8/signalwire_agents.egg-info → signalwire_agents-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 1.0.8
+Version: 1.0.10
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/pyproject.toml

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

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/signalwire_agents/__init__.py

@@ -18,7 +18,7 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "1.0.8"
+__version__ = "1.0.10"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/signalwire_agents/core/agent_base.py

@@ -317,13 +317,32 @@ class AgentBase(
     def get_full_url(self, include_auth: bool = False) -> str:
         """
         Get the full URL for this agent's endpoint
-        
+
         Args:
             include_auth: Whether to include authentication credentials in the URL
-            
+
         Returns:
             Full URL including host, port, and route (with auth if requested)
         """
+        # If _proxy_url_base is set (e.g., from request URL detection), use it
+        if hasattr(self, '_proxy_url_base') and self._proxy_url_base:
+            base_url = self._proxy_url_base.rstrip('/')
+            # Add authentication if requested
+            if include_auth:
+                username, password = self.get_basic_auth_credentials()
+                if username and password:
+                    from urllib.parse import urlparse, urlunparse
+                    parsed = urlparse(base_url)
+                    base_url = urlunparse((
+                        parsed.scheme,
+                        f"{username}:{password}@{parsed.netloc}",
+                        parsed.path,
+                        parsed.params,
+                        parsed.query,
+                        parsed.fragment
+                    ))
+            return base_url
+
         mode = get_execution_mode()
 
         if mode == 'cgi':

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/signalwire_agents/core/mixins/auth_mixin.py

@@ -196,11 +196,8 @@ class AuthMixin:
             return False
             
         # Check for authorization header (case-insensitive)
-        auth_header = None
-        for key in request.headers:
-            if key.lower() == 'authorization':
-                auth_header = request.headers[key]
-                break
+        # Flask headers can be accessed directly with .get() which is case-insensitive
+        auth_header = request.headers.get('Authorization')
                 
         if not auth_header or not auth_header.startswith('Basic '):
             return False
@@ -246,14 +243,10 @@ class AuthMixin:
         """
         if not hasattr(req, 'headers'):
             return False
-            
-        # Check for authorization header (case-insensitive)
-        auth_header = None
-        for key, value in req.headers.items():
-            if key.lower() == 'authorization':
-                auth_header = value
-                break
-                
+
+        # Check for authorization header - use .get() which works with both dict and Flask headers
+        auth_header = req.headers.get('Authorization')
+
         if not auth_header or not auth_header.startswith('Basic '):
             return False
             

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/signalwire_agents/core/mixins/serverless_mixin.py

@@ -80,52 +80,76 @@ class ServerlessMixin:
                 # Check authentication in Lambda mode
                 if not self._check_lambda_auth(event):
                     return self._send_lambda_auth_challenge()
-                
+
                 if event:
-                    path = event.get('pathParameters', {}).get('proxy', '') if event.get('pathParameters') else ''
-                    if not path:
-                        swml_response = self._render_swml()
+                    # Support both HTTP API (v2) and REST API (v1) payload formats
+                    # HTTP API v2 uses rawPath, REST API v1 uses pathParameters.proxy
+                    path = event.get('rawPath', '').strip('/')
+                    if not path and event.get('pathParameters'):
+                        path = event.get('pathParameters', {}).get('proxy', '')
+
+                    # Parse request body if present
+                    args = {}
+                    call_id = None
+                    raw_data = None
+                    function_name = None
+
+                    body_content = event.get('body')
+                    if body_content:
+                        try:
+                            if event.get('isBase64Encoded'):
+                                import base64
+                                body_content = base64.b64decode(body_content).decode('utf-8')
+                            if isinstance(body_content, str):
+                                raw_data = json.loads(body_content)
+                            else:
+                                raw_data = body_content
+
+                            call_id = raw_data.get("call_id")
+                            function_name = raw_data.get("function")
+
+                            # Extract arguments like the FastAPI handler does
+                            if "argument" in raw_data and isinstance(raw_data["argument"], dict):
+                                if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
+                                    args = raw_data["argument"]["parsed"][0]
+                                elif "raw" in raw_data["argument"]:
+                                    try:
+                                        args = json.loads(raw_data["argument"]["raw"])
+                                    except Exception:
+                                        pass
+                        except Exception:
+                            # If parsing fails, continue with empty args
+                            pass
+
+                    # Determine if this is a SWAIG function call
+                    # Case 1: /swaig endpoint with function name in body
+                    # Case 2: /{function_name} path-based routing
+                    # Case 3: Root path - return SWML
+
+                    if path in ('swaig', 'swaig/') and function_name:
+                        # /swaig endpoint with function name in body
+                        result = self._execute_swaig_function(function_name, args, call_id, raw_data)
                         return {
                             "statusCode": 200,
                             "headers": {"Content-Type": "application/json"},
-                            "body": swml_response
+                            "body": json.dumps(result) if isinstance(result, dict) else str(result)
                         }
-                    else:
-                        # Parse Lambda event for SWAIG function call
-                        args = {}
-                        call_id = None
-                        raw_data = None
-                        
-                        # Parse request body if present
-                        body_content = event.get('body')
-                        if body_content:
-                            try:
-                                if isinstance(body_content, str):
-                                    raw_data = json.loads(body_content)
-                                else:
-                                    raw_data = body_content
-                                    
-                                call_id = raw_data.get("call_id")
-                                
-                                # Extract arguments like the FastAPI handler does
-                                if "argument" in raw_data and isinstance(raw_data["argument"], dict):
-                                    if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
-                                        args = raw_data["argument"]["parsed"][0]
-                                    elif "raw" in raw_data["argument"]:
-                                        try:
-                                            args = json.loads(raw_data["argument"]["raw"])
-                                        except Exception:
-                                            pass
-                            except Exception:
-                                # If parsing fails, continue with empty args
-                                pass
-                        
+                    elif path and path not in ('', 'swaig', 'swaig/'):
+                        # Path-based function routing (e.g., /say_hello)
                         result = self._execute_swaig_function(path, args, call_id, raw_data)
                         return {
                             "statusCode": 200,
                             "headers": {"Content-Type": "application/json"},
                             "body": json.dumps(result) if isinstance(result, dict) else str(result)
                         }
+                    else:
+                        # Root path or /swaig without function - return SWML
+                        swml_response = self._render_swml()
+                        return {
+                            "statusCode": 200,
+                            "headers": {"Content-Type": "application/json"},
+                            "body": swml_response
+                        }
                 else:
                     # Handle case when event is None (direct Lambda call with no event)
                     swml_response = self._render_swml()
@@ -152,7 +176,9 @@ class ServerlessMixin:
                 
         except Exception as e:
             import logging
+            import traceback
             logging.error(f"Error in serverless request handler: {e}")
+            logging.error(f"Traceback: {traceback.format_exc()}")
             if mode == 'lambda':
                 return {
                     "statusCode": 500,
@@ -232,63 +258,91 @@ class ServerlessMixin:
     def _handle_google_cloud_function_request(self, request):
         """
         Handle Google Cloud Functions specific requests
-        
+
         Args:
             request: Flask request object from Google Cloud Functions
-            
+
         Returns:
             Flask response object
         """
         try:
+            from urllib.parse import urlparse
+
             # Get the path from the request
             path = request.path.strip('/')
-            
-            if not path:
-                # Root request - return SWML
-                swml_response = self._render_swml()
-                from flask import Response
+
+            # Try to detect and set the base URL from the request for webhook URLs
+            base_url = None
+            if hasattr(request, 'url') and request.url:
+                parsed = urlparse(request.url)
+                # Get the base URL without the path
+                base_url = f"{parsed.scheme}://{parsed.netloc}"
+
+            # Set the proxy URL base so SWML renders correct webhook URLs
+            if base_url and not getattr(self, '_proxy_url_base_from_env', False):
+                self._proxy_url_base = base_url
+
+            # Parse request body if present
+            args = {}
+            call_id = None
+            raw_data = None
+            function_name = None
+
+            if request.method == 'POST':
+                try:
+                    if request.is_json:
+                        raw_data = request.get_json()
+                    else:
+                        raw_data = json.loads(request.get_data(as_text=True))
+
+                    call_id = raw_data.get("call_id")
+                    function_name = raw_data.get("function")
+
+                    # Extract arguments like the FastAPI handler does
+                    if "argument" in raw_data and isinstance(raw_data["argument"], dict):
+                        if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
+                            args = raw_data["argument"]["parsed"][0]
+                        elif "raw" in raw_data["argument"]:
+                            try:
+                                args = json.loads(raw_data["argument"]["raw"])
+                            except Exception:
+                                pass
+                except Exception:
+                    # If parsing fails, continue with empty args
+                    pass
+
+            # Determine if this is a SWAIG function call
+            # Case 1: /swaig endpoint with function name in body
+            # Case 2: /{function_name} path-based routing
+            # Case 3: Root path - return SWML
+
+            from flask import Response
+
+            if path in ('swaig', 'swaig/') and function_name:
+                # /swaig endpoint with function name in body
+                result = self._execute_swaig_function(function_name, args, call_id, raw_data)
                 return Response(
-                    response=swml_response,
+                    response=json.dumps(result) if isinstance(result, dict) else str(result),
                     status=200,
                     headers={"Content-Type": "application/json"}
                 )
-            else:
-                # SWAIG function call
-                args = {}
-                call_id = None
-                raw_data = None
-                
-                # Parse request data
-                if request.method == 'POST':
-                    try:
-                        if request.is_json:
-                            raw_data = request.get_json()
-                        else:
-                            raw_data = json.loads(request.get_data(as_text=True))
-                        
-                        call_id = raw_data.get("call_id")
-                        
-                        # Extract arguments like the FastAPI handler does
-                        if "argument" in raw_data and isinstance(raw_data["argument"], dict):
-                            if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
-                                args = raw_data["argument"]["parsed"][0]
-                            elif "raw" in raw_data["argument"]:
-                                try:
-                                    args = json.loads(raw_data["argument"]["raw"])
-                                except Exception:
-                                    pass
-                    except Exception:
-                        # If parsing fails, continue with empty args
-                        pass
-                
+            elif path and path not in ('', 'swaig', 'swaig/'):
+                # Path-based function routing (e.g., /say_hello)
                 result = self._execute_swaig_function(path, args, call_id, raw_data)
-                from flask import Response
                 return Response(
                     response=json.dumps(result) if isinstance(result, dict) else str(result),
                     status=200,
                     headers={"Content-Type": "application/json"}
                 )
-                
+            else:
+                # Root path or /swaig without function - return SWML
+                swml_response = self._render_swml()
+                return Response(
+                    response=swml_response,
+                    status=200,
+                    headers={"Content-Type": "application/json"}
+                )
+
         except Exception as e:
             import logging
             logging.error(f"Error in Google Cloud Function request handler: {e}")
@@ -302,61 +356,99 @@ class ServerlessMixin:
     def _handle_azure_function_request(self, req):
         """
         Handle Azure Functions specific requests
-        
+
         Args:
             req: Azure Functions HttpRequest object
-            
+
         Returns:
             Azure Functions HttpResponse object
         """
         try:
             import azure.functions as func
-            
-            # Get the path from the request
-            path = req.url.split('/')[-1] if req.url else ''
-            
-            if not path or path == 'api':
-                # Root request - return SWML
-                swml_response = self._render_swml()
+            from urllib.parse import urlparse
+
+            # Get the path from the request URL
+            # Azure Functions URLs look like: https://app.azurewebsites.net/api/function_name/path
+            path = ''
+            base_url = None
+            if req.url:
+                parsed = urlparse(req.url)
+                # Full path after /api/ e.g. "function_app" or "function_app/swaig"
+                url_parts = req.url.split('/api/')
+                if len(url_parts) > 1:
+                    full_path = url_parts[1].strip('/')
+                    # Split into function name and sub-path
+                    path_parts = full_path.split('/', 1)
+                    function_app_name = path_parts[0] if path_parts else ''
+                    path = path_parts[1] if len(path_parts) > 1 else ''
+
+                    # Base URL includes the function app name for webhook URLs
+                    # e.g., https://app.azurewebsites.net/api/function_app
+                    base_url = f"{parsed.scheme}://{parsed.netloc}/api/{function_app_name}"
+                else:
+                    base_url = f"{parsed.scheme}://{parsed.netloc}/api"
+
+            # Set the proxy URL base so SWML renders correct webhook URLs
+            if base_url and not getattr(self, '_proxy_url_base_from_env', False):
+                self._proxy_url_base = base_url
+
+            # Parse request body if present
+            args = {}
+            call_id = None
+            raw_data = None
+            function_name = None
+
+            if req.method == 'POST':
+                try:
+                    body = req.get_body()
+                    if body:
+                        raw_data = json.loads(body.decode('utf-8'))
+                        call_id = raw_data.get("call_id")
+                        function_name = raw_data.get("function")
+
+                        # Extract arguments like the FastAPI handler does
+                        if "argument" in raw_data and isinstance(raw_data["argument"], dict):
+                            if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
+                                args = raw_data["argument"]["parsed"][0]
+                            elif "raw" in raw_data["argument"]:
+                                try:
+                                    args = json.loads(raw_data["argument"]["raw"])
+                                except Exception:
+                                    pass
+                except Exception:
+                    # If parsing fails, continue with empty args
+                    pass
+
+            # Determine if this is a SWAIG function call
+            # Case 1: /swaig endpoint with function name in body
+            # Case 2: /{function_name} path-based routing
+            # Case 3: Root path - return SWML
+
+            if path in ('swaig', 'swaig/') and function_name:
+                # /swaig endpoint with function name in body
+                result = self._execute_swaig_function(function_name, args, call_id, raw_data)
                 return func.HttpResponse(
-                    body=swml_response,
+                    body=json.dumps(result) if isinstance(result, dict) else str(result),
                     status_code=200,
                     headers={"Content-Type": "application/json"}
                 )
-            else:
-                # SWAIG function call
-                args = {}
-                call_id = None
-                raw_data = None
-                
-                # Parse request data
-                if req.method == 'POST':
-                    try:
-                        body = req.get_body()
-                        if body:
-                            raw_data = json.loads(body.decode('utf-8'))
-                            call_id = raw_data.get("call_id")
-                            
-                            # Extract arguments like the FastAPI handler does
-                            if "argument" in raw_data and isinstance(raw_data["argument"], dict):
-                                if "parsed" in raw_data["argument"] and isinstance(raw_data["argument"]["parsed"], list) and raw_data["argument"]["parsed"]:
-                                    args = raw_data["argument"]["parsed"][0]
-                                elif "raw" in raw_data["argument"]:
-                                    try:
-                                        args = json.loads(raw_data["argument"]["raw"])
-                                    except Exception:
-                                        pass
-                    except Exception:
-                        # If parsing fails, continue with empty args
-                        pass
-                
+            elif path and path not in ('', 'api', 'swaig', 'swaig/'):
+                # Path-based function routing (e.g., /say_hello)
                 result = self._execute_swaig_function(path, args, call_id, raw_data)
                 return func.HttpResponse(
                     body=json.dumps(result) if isinstance(result, dict) else str(result),
                     status_code=200,
                     headers={"Content-Type": "application/json"}
                 )
-                
+            else:
+                # Root path or /swaig without function - return SWML
+                swml_response = self._render_swml()
+                return func.HttpResponse(
+                    body=swml_response,
+                    status_code=200,
+                    headers={"Content-Type": "application/json"}
+                )
+
         except Exception as e:
             import logging
             logging.error(f"Error in Azure Function request handler: {e}")

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10}/signalwire_agents/core/mixins/web_mixin.py

@@ -302,7 +302,7 @@ class WebMixin:
                 response = self.handle_serverless_request(event, context, mode)
                 print(response)
                 return response
-            elif mode == 'lambda':
+            elif mode in ['lambda', 'google_cloud_function']:
                 return self.handle_serverless_request(event, context, mode)
             else:
                 # Server mode - use existing serve method

{signalwire_agents-1.0.8 → signalwire_agents-1.0.10/signalwire_agents.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 1.0.8
+Version: 1.0.10
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT