signalwire-agents 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

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__ = "0.1.14"
+__version__ = "0.1.16"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents/core/agent_base.py

@@ -25,7 +25,7 @@ import re
 import signal
 import sys
 from typing import Optional, Union, List, Dict, Any, Tuple, Callable, Type
-from urllib.parse import urlparse, urlencode
+from urllib.parse import urlparse, urlencode, urlunparse
 
 try:
     import fastapi
@@ -1299,51 +1299,61 @@ class AgentBase(SWMLService):
             script_name = os.getenv('SCRIPT_NAME', '')
             base_url = f"{protocol}://{host}{script_name}"
         elif mode == 'lambda':
-            function_url = os.getenv('AWS_LAMBDA_FUNCTION_URL')
-            if function_url and ('amazonaws.com' in function_url or 'on.aws' in function_url):
-                base_url = function_url.rstrip('/')
+            # AWS Lambda Function URL format
+            lambda_url = os.getenv('AWS_LAMBDA_FUNCTION_URL')
+            if lambda_url:
+                base_url = lambda_url.rstrip('/')
             else:
-                api_id = os.getenv('AWS_API_GATEWAY_ID')
-                if api_id:
-                    region = os.getenv('AWS_REGION', 'us-east-1')
-                    stage = os.getenv('AWS_API_GATEWAY_STAGE', 'prod')
-                    base_url = f"https://{api_id}.execute-api.{region}.amazonaws.com/{stage}"
-                else:
-                    import logging
-                    logging.warning("Lambda mode detected but no URL configuration found")
-                    base_url = "https://lambda-url-not-configured"
-        elif mode == 'cloud_function':
-            function_url = os.getenv('FUNCTION_URL')
-            if function_url:
-                base_url = function_url
+                # Fallback construction for Lambda
+                region = os.getenv('AWS_REGION', 'us-east-1')
+                function_name = os.getenv('AWS_LAMBDA_FUNCTION_NAME', 'unknown')
+                base_url = f"https://{function_name}.lambda-url.{region}.on.aws"
+        elif mode == 'google_cloud_function':
+            # Google Cloud Functions URL format
+            project_id = os.getenv('GOOGLE_CLOUD_PROJECT') or os.getenv('GCP_PROJECT')
+            region = os.getenv('FUNCTION_REGION') or os.getenv('GOOGLE_CLOUD_REGION', 'us-central1')
+            service_name = os.getenv('K_SERVICE') or os.getenv('FUNCTION_TARGET', 'unknown')
+            
+            if project_id:
+                base_url = f"https://{region}-{project_id}.cloudfunctions.net/{service_name}"
             else:
-                project = os.getenv('GOOGLE_CLOUD_PROJECT')
-                if project:
-                    region = os.getenv('GOOGLE_CLOUD_REGION', 'us-central1')
-                    service = os.getenv('K_SERVICE', 'function')
-                    base_url = f"https://{region}-{project}.cloudfunctions.net/{service}"
-                else:
-                    import logging
-                    logging.warning("Cloud Function mode detected but no URL configuration found")
-                    base_url = "https://cloud-function-url-not-configured"
-        else:
-            # Server mode - preserve existing logic
-            if self._proxy_url_base:
-                proxy_base = self._proxy_url_base.rstrip('/')
-                route = self.route if self.route.startswith('/') else f"/{self.route}"
-                base_url = f"{proxy_base}{route}"
+                # Fallback for local testing or incomplete environment
+                base_url = f"https://localhost:8080"
+        elif mode == 'azure_function':
+            # Azure Functions URL format
+            function_app_name = os.getenv('WEBSITE_SITE_NAME') or os.getenv('AZURE_FUNCTIONS_APP_NAME')
+            function_name = os.getenv('AZURE_FUNCTION_NAME', 'unknown')
+            
+            if function_app_name:
+                base_url = f"https://{function_app_name}.azurewebsites.net/api/{function_name}"
             else:
-                if self.host in ("0.0.0.0", "127.0.0.1", "localhost"):
-                    host = "localhost"
-                else:
-                    host = self.host
-                base_url = f"http://{host}:{self.port}{self.route}"
-            
-        # Add auth if requested (applies to all modes now)
+                # Fallback for local testing
+                base_url = f"https://localhost:7071/api/{function_name}"
+        else:
+            # Server mode
+            protocol = 'https' if self.ssl_cert and self.ssl_key else 'http'
+            base_url = f"{protocol}://{self.host}:{self.port}"
+        
+        # Add route if not already included (for server mode)
+        if mode == 'server' and self.route and not base_url.endswith(self.route):
+            base_url = f"{base_url}/{self.route.lstrip('/')}"
+        
+        # Add authentication if requested
         if include_auth:
-            username, password = self._basic_auth
-            url = urlparse(base_url)
-            return url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
+            username, password = self.get_basic_auth_credentials()
+            if username and password:
+                # Parse URL to insert auth
+                from urllib.parse import urlparse, urlunparse
+                parsed = urlparse(base_url)
+                # Reconstruct with auth
+                base_url = urlunparse((
+                    parsed.scheme,
+                    f"{username}:{password}@{parsed.netloc}",
+                    parsed.path,
+                    parsed.params,
+                    parsed.query,
+                    parsed.fragment
+                ))
         
         return base_url
         
@@ -1878,6 +1888,124 @@ class AgentBase(SWMLService):
             else:
                 raise
 
+    def _check_cgi_auth(self) -> bool:
+        """
+        Check basic auth in CGI mode using environment variables
+        
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        # Check for HTTP_AUTHORIZATION environment variable
+        auth_header = os.getenv('HTTP_AUTHORIZATION')
+        if not auth_header:
+            # Also check for REMOTE_USER (if web server handled auth)
+            remote_user = os.getenv('REMOTE_USER')
+            if remote_user:
+                # If web server handled auth, trust it
+                return True
+            return False
+        
+        if not auth_header.startswith('Basic '):
+            return False
+            
+        try:
+            # Decode the base64 credentials
+            credentials = base64.b64decode(auth_header[6:]).decode("utf-8")
+            username, password = credentials.split(":", 1)
+            return self.validate_basic_auth(username, password)
+        except Exception:
+            return False
+    
+    def _send_cgi_auth_challenge(self) -> str:
+        """
+        Send authentication challenge in CGI mode
+        
+        Returns:
+            HTTP response with 401 status and WWW-Authenticate header
+        """
+        # In CGI, we need to output the complete HTTP response
+        response = "Status: 401 Unauthorized\r\n"
+        response += "WWW-Authenticate: Basic realm=\"SignalWire Agent\"\r\n"
+        response += "Content-Type: application/json\r\n"
+        response += "\r\n"
+        response += json.dumps({"error": "Unauthorized"})
+        return response
+
+    def _check_lambda_auth(self, event) -> bool:
+        """
+        Check basic auth in Lambda mode using event headers
+        
+        Args:
+            event: Lambda event object containing headers
+            
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        if not event or 'headers' not in event:
+            return False
+            
+        headers = event['headers']
+        
+        # Check for authorization header (case-insensitive)
+        auth_header = None
+        for key, value in headers.items():
+            if key.lower() == 'authorization':
+                auth_header = value
+                break
+                
+        if not auth_header or not auth_header.startswith('Basic '):
+            return False
+            
+        try:
+            # Decode the base64 credentials
+            credentials = base64.b64decode(auth_header[6:]).decode("utf-8")
+            username, password = credentials.split(":", 1)
+            return self.validate_basic_auth(username, password)
+        except Exception:
+            return False
+    
+    def _send_lambda_auth_challenge(self) -> dict:
+        """
+        Send authentication challenge in Lambda mode
+        
+        Returns:
+            Lambda response with 401 status and WWW-Authenticate header
+        """
+        return {
+            "statusCode": 401,
+            "headers": {
+                "WWW-Authenticate": "Basic realm=\"SignalWire Agent\"",
+                "Content-Type": "application/json"
+            },
+            "body": json.dumps({"error": "Unauthorized"})
+        }
+    
+    def _check_cloud_function_auth(self, request) -> bool:
+        """
+        Check basic auth in Cloud Function mode
+        
+        Args:
+            request: Cloud Function request object
+            
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        # This would need to be implemented based on the specific
+        # cloud function framework being used (Flask, etc.)
+        # For now, return True to maintain existing behavior
+        return True
+    
+    def _send_cloud_function_auth_challenge(self):
+        """
+        Send authentication challenge in Cloud Function mode
+        
+        Returns:
+            Cloud Function response with 401 status
+        """
+        # This would need to be implemented based on the specific
+        # cloud function framework being used
+        return {"error": "Unauthorized", "status": 401}
+
     def handle_serverless_request(self, event=None, context=None, mode=None):
         """
         Handle serverless environment requests (CGI, Lambda, Cloud Functions)
@@ -1895,6 +2023,10 @@ class AgentBase(SWMLService):
         
         try:
             if mode == 'cgi':
+                # Check authentication in CGI mode
+                if not self._check_cgi_auth():
+                    return self._send_cgi_auth_challenge()
+                
                 path_info = os.getenv('PATH_INFO', '').strip('/')
                 if not path_info:
                     return self._render_swml()
@@ -1930,6 +2062,10 @@ class AgentBase(SWMLService):
                     return self._execute_swaig_function(path_info, args, call_id, raw_data)
             
             elif mode == 'lambda':
+                # 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:
@@ -1984,7 +2120,26 @@ class AgentBase(SWMLService):
                         "body": swml_response
                     }
             
-            elif mode in ['cloud_function', 'azure_function']:
+            elif mode == 'google_cloud_function':
+                # Check authentication in Google Cloud Functions mode
+                if not self._check_google_cloud_function_auth(event):
+                    return self._send_google_cloud_function_auth_challenge()
+                
+                return self._handle_google_cloud_function_request(event)
+            
+            elif mode == 'azure_function':
+                # Check authentication in Azure Functions mode
+                if not self._check_azure_function_auth(event):
+                    return self._send_azure_function_auth_challenge()
+                
+                return self._handle_azure_function_request(event)
+            
+            elif mode in ['cloud_function']:
+                # Legacy cloud function mode - deprecated
+                # Check authentication in Cloud Function mode
+                if not self._check_cloud_function_auth(event):
+                    return self._send_cloud_function_auth_challenge()
+                
                 return self._handle_cloud_function_request(event)
                 
         except Exception as e:
@@ -3410,3 +3565,245 @@ class AgentBase(SWMLService):
     def has_skill(self, skill_name: str) -> bool:
         """Check if skill is loaded"""
         return self.skill_manager.has_skill(skill_name)
+
+    def _check_google_cloud_function_auth(self, request) -> bool:
+        """
+        Check basic auth in Google Cloud Functions mode using request headers
+        
+        Args:
+            request: Flask request object or similar containing headers
+            
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        if not hasattr(request, 'headers'):
+            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
+                
+        if not auth_header or not auth_header.startswith('Basic '):
+            return False
+            
+        try:
+            import base64
+            encoded_credentials = auth_header[6:]  # Remove 'Basic '
+            decoded_credentials = base64.b64decode(encoded_credentials).decode('utf-8')
+            provided_username, provided_password = decoded_credentials.split(':', 1)
+            
+            expected_username, expected_password = self.get_basic_auth_credentials()
+            return (provided_username == expected_username and 
+                    provided_password == expected_password)
+        except Exception:
+            return False
+
+    def _check_azure_function_auth(self, req) -> bool:
+        """
+        Check basic auth in Azure Functions mode using request object
+        
+        Args:
+            req: Azure Functions request object containing headers
+            
+        Returns:
+            True if auth is valid, False otherwise
+        """
+        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
+                
+        if not auth_header or not auth_header.startswith('Basic '):
+            return False
+            
+        try:
+            import base64
+            encoded_credentials = auth_header[6:]  # Remove 'Basic '
+            decoded_credentials = base64.b64decode(encoded_credentials).decode('utf-8')
+            provided_username, provided_password = decoded_credentials.split(':', 1)
+            
+            expected_username, expected_password = self.get_basic_auth_credentials()
+            return (provided_username == expected_username and 
+                    provided_password == expected_password)
+        except Exception:
+            return False
+
+    def _send_google_cloud_function_auth_challenge(self):
+        """
+        Send authentication challenge in Google Cloud Functions mode
+        
+        Returns:
+            Flask-compatible response with 401 status and WWW-Authenticate header
+        """
+        from flask import Response
+        return Response(
+            response=json.dumps({"error": "Unauthorized"}),
+            status=401,
+            headers={
+                "WWW-Authenticate": "Basic realm=\"SignalWire Agent\"",
+                "Content-Type": "application/json"
+            }
+        )
+    
+    def _send_azure_function_auth_challenge(self):
+        """
+        Send authentication challenge in Azure Functions mode
+        
+        Returns:
+            Azure Functions response with 401 status and WWW-Authenticate header
+        """
+        import azure.functions as func
+        return func.HttpResponse(
+            body=json.dumps({"error": "Unauthorized"}),
+            status_code=401,
+            headers={
+                "WWW-Authenticate": "Basic realm=\"SignalWire Agent\"",
+                "Content-Type": "application/json"
+            }
+        )
+
+    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:
+            # 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
+                return Response(
+                    response=swml_response,
+                    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
+                
+                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"}
+                )
+                
+        except Exception as e:
+            import logging
+            logging.error(f"Error in Google Cloud Function request handler: {e}")
+            from flask import Response
+            return Response(
+                response=json.dumps({"error": str(e)}),
+                status=500,
+                headers={"Content-Type": "application/json"}
+            )
+
+    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()
+                return func.HttpResponse(
+                    body=swml_response,
+                    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
+                
+                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"}
+                )
+                
+        except Exception as e:
+            import logging
+            logging.error(f"Error in Azure Function request handler: {e}")
+            import azure.functions as func
+            return func.HttpResponse(
+                body=json.dumps({"error": str(e)}),
+                status_code=500,
+                headers={"Content-Type": "application/json"}
+            )

signalwire_agents/core/function_result.py

@@ -281,7 +281,7 @@ class SwaigFunctionResult:
         else:
             raise TypeError("swml_content must be string, dict, or SWML object")
         
-        action = {"SWML": swml_data}
+        action = swml_data
         if transfer:
             action["transfer"] = "true"
         

signalwire_agents/core/logging_config.py

@@ -127,19 +127,34 @@ class BoundStructuredLoggerWrapper(StructuredLoggerWrapper):
         return BoundStructuredLoggerWrapper(self._logger, new_bound_data)
 
 
-def get_execution_mode() -> str:
+def get_execution_mode():
     """
     Determine the execution mode based on environment variables
     
     Returns:
-        'cgi' if running in CGI mode
-        'lambda' if running in AWS Lambda 
-        'server' for normal server mode
+        str: 'server', 'cgi', 'lambda', 'google_cloud_function', 'azure_function', or 'unknown'
     """
+    # Check for CGI environment
     if os.getenv('GATEWAY_INTERFACE'):
         return 'cgi'
+    
+    # Check for AWS Lambda environment
     if os.getenv('AWS_LAMBDA_FUNCTION_NAME') or os.getenv('LAMBDA_TASK_ROOT'):
         return 'lambda'
+    
+    # Check for Google Cloud Functions environment
+    if (os.getenv('FUNCTION_TARGET') or 
+        os.getenv('K_SERVICE') or 
+        os.getenv('GOOGLE_CLOUD_PROJECT')):
+        return 'google_cloud_function'
+    
+    # Check for Azure Functions environment
+    if (os.getenv('AZURE_FUNCTIONS_ENVIRONMENT') or 
+        os.getenv('FUNCTIONS_WORKER_RUNTIME') or
+        os.getenv('AzureWebJobsStorage')):
+        return 'azure_function'
+    
+    # Default to server mode
     return 'server'
 
 

{signalwire_agents-0.1.14.dist-info → signalwire_agents-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.14
+Version: 0.1.16
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 Project-URL: Homepage, https://github.com/signalwire/signalwire-ai-agents

{signalwire_agents-0.1.14.dist-info → signalwire_agents-0.1.16.dist-info}/RECORD

@@ -1,15 +1,15 @@
-signalwire_agents/__init__.py,sha256=VdzDfggQq5yncBmgKKO7HsQH2nolhgdHMlLChwu5kyg,2707
+signalwire_agents/__init__.py,sha256=uXl3_WmqkymgMz9EDcAcLEXVXEbdL928PiK8--bJvYI,2707
 signalwire_agents/agent_server.py,sha256=3Or8rIMAqW750V-XitBUMgOpW9BAIXmKXoGq7LkejAA,24988
 signalwire_agents/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
 signalwire_agents/cli/__init__.py,sha256=Iy2BfWDWBEZoA1cyHTDsooBSVMx4vH5Ddhr3sEuFe8c,197
 signalwire_agents/cli/build_search.py,sha256=PnGoIZVfIbSF21rb0m0_ceIL-8lJx59_qXrrl8l2yBE,22340
 signalwire_agents/cli/test_swaig.py,sha256=CqfdBWE8_fiFnFWHbv9ouU1eUA_rGUUHwyOf_iUaZFU,101851
 signalwire_agents/core/__init__.py,sha256=mVDLbpq1pg_WwiqsQR28NNZwJ6-VUXFIfg-vN7pk0ew,806
-signalwire_agents/core/agent_base.py,sha256=F4ZxvFHK6FDs-jIaYSqua8QWvnoKA9wOeuomxnJO20g,140489
+signalwire_agents/core/agent_base.py,sha256=0MA1i6honMKfyEIyCrVgS7WAR-iL3v3n8u0ZI8B-hHA,155944
 signalwire_agents/core/contexts.py,sha256=h7hra4xoiKAUdVyJhcKggl8X9EoqwTVWBmNMp-sEsuc,9598
 signalwire_agents/core/data_map.py,sha256=U-HLEZQomWf-UI0-nLAE8g1oyRdE5bU_WxQpboI2YI4,17695
-signalwire_agents/core/function_result.py,sha256=SP46vPAliEzwh3JeeSxmLD_f7_ixRxMBtpSl3t7jieU,45370
-signalwire_agents/core/logging_config.py,sha256=A4huPkWicnpd7g7M4XYYKMALQqLSrhtIu21811nLV5c,12622
+signalwire_agents/core/function_result.py,sha256=GGmd2gAB9uJFFyldrhC86LCmpCnccU1bb-3gZVW2rxE,45360
+signalwire_agents/core/logging_config.py,sha256=x4d_RAjBjVpJOFA2vXnPP2dNr13BZHz091J5rGpC77Y,13142
 signalwire_agents/core/pom_builder.py,sha256=ywuiIfP8BeLBPo_G4X1teZlG6zTCMkW71CZnmyoDTAQ,6636
 signalwire_agents/core/skill_base.py,sha256=lOpVTLhD9NjStF7Lxh6bAQUGa3DpNYV4agXJRakRuX0,4258
 signalwire_agents/core/skill_manager.py,sha256=XWq4MeDQ3kmM4Th8qI-Gx5klokDHNZ-K9cChJPW-zmQ,8113
@@ -58,10 +58,10 @@ signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_Pu
 signalwire_agents/utils/schema_utils.py,sha256=i4okv_O9bUApwT_jJf4Yoij3bLCrGrW3DC-vzSy2RuY,16392
 signalwire_agents/utils/token_generators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/validators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
-signalwire_agents-0.1.14.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
-signalwire_agents-0.1.14.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.14.dist-info/METADATA,sha256=_VCXeDp5iMOLmkdHJlognjxF5rLQV_rzp8mhiJpbADM,34572
-signalwire_agents-0.1.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-signalwire_agents-0.1.14.dist-info/entry_points.txt,sha256=LRwltbVfaKUFMYmQoMxJGTT_-iQm0ftzXK0xPfD64Is,138
-signalwire_agents-0.1.14.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.14.dist-info/RECORD,,
+signalwire_agents-0.1.16.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
+signalwire_agents-0.1.16.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.16.dist-info/METADATA,sha256=Wa9zmHC-iN-0ftjlPqeLdcjDsAhLpBT2b2WBCeajnkY,34572
+signalwire_agents-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalwire_agents-0.1.16.dist-info/entry_points.txt,sha256=LRwltbVfaKUFMYmQoMxJGTT_-iQm0ftzXK0xPfD64Is,138
+signalwire_agents-0.1.16.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.16.dist-info/RECORD,,