signalwire-agents 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

signalwire_agents/utils/schema_utils.py

@@ -0,0 +1,357 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+
+"""
+Utilities for working with the SWML JSON schema.
+
+This module provides functions for loading, parsing, and validating SWML schemas.
+It also provides utilities for working with SWML documents based on the schema.
+"""
+
+import json
+import os
+import re
+from typing import Dict, List, Any, Optional, Set, Tuple, Callable
+
+
+class SchemaUtils:
+    """
+    Utilities for working with SWML JSON schema.
+    
+    This class provides methods for:
+    - Loading and parsing schema files
+    - Extracting verb definitions
+    - Validating SWML objects against the schema
+    - Generating helpers for schema operations
+    """
+    
+    def __init__(self, schema_path: Optional[str] = None):
+        """
+        Initialize the SchemaUtils with the provided schema
+        
+        Args:
+            schema_path: Path to the schema file (optional)
+        """
+        self.schema_path = schema_path
+        if not self.schema_path:
+            self.schema_path = self._get_default_schema_path()
+            print(f"No schema_path provided, using default: {self.schema_path}")
+        
+        self.schema = self.load_schema()
+        self.verbs = self._extract_verb_definitions()
+        print(f"Extracted {len(self.verbs)} verbs from schema")
+        if self.verbs:
+            print(f"First few verbs: {list(self.verbs.keys())[:5]}")
+        
+    def _get_default_schema_path(self) -> str:
+        """
+        Get the default path to the schema file
+        
+        Returns:
+            Path to the schema file
+        """
+        # Default path is the schema.json in the root directory
+        package_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        default_path = os.path.join(package_dir, "schema.json")
+        print(f"Default schema path: {default_path}")
+        print(f"Path exists: {os.path.exists(default_path)}")
+        
+        return default_path
+        
+    def load_schema(self) -> Dict[str, Any]:
+        """
+        Load the JSON schema from the specified path
+        
+        Returns:
+            The schema as a dictionary
+        """
+        if not self.schema_path:
+            print(f"Warning: No schema path provided. Using empty schema.")
+            return {}
+            
+        try:
+            print(f"Attempting to load schema from: {self.schema_path}")
+            print(f"File exists: {os.path.exists(self.schema_path)}")
+            
+            if os.path.exists(self.schema_path):
+                with open(self.schema_path, "r") as f:
+                    schema = json.load(f)
+                print(f"Successfully loaded schema from {self.schema_path}")
+                print(f"Schema has {len(schema.keys()) if schema else 0} top-level keys")
+                if "$defs" in schema:
+                    print(f"Schema has {len(schema['$defs'])} definitions")
+                return schema
+            else:
+                print(f"Schema file not found at {self.schema_path}")
+                return {}
+        except (FileNotFoundError, json.JSONDecodeError) as e:
+            print(f"Error loading schema: {e}")
+            print(f"Using empty schema as fallback")
+            return {}
+    
+    def _extract_verb_definitions(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Extract verb definitions from the schema
+        
+        Returns:
+            A dictionary mapping verb names to their definitions
+        """
+        verbs = {}
+        
+        # Extract from SWMLMethod anyOf
+        if "$defs" in self.schema and "SWMLMethod" in self.schema["$defs"]:
+            swml_method = self.schema["$defs"]["SWMLMethod"]
+            print(f"Found SWMLMethod in schema with keys: {swml_method.keys()}")
+            
+            if "anyOf" in swml_method:
+                print(f"Found anyOf in SWMLMethod with {len(swml_method['anyOf'])} items")
+                
+                for ref in swml_method["anyOf"]:
+                    if "$ref" in ref:
+                        # Extract the verb name from the reference
+                        verb_ref = ref["$ref"]
+                        verb_name = verb_ref.split("/")[-1]
+                        print(f"Processing verb reference: {verb_ref} -> {verb_name}")
+                        
+                        # Look up the verb definition
+                        if verb_name in self.schema["$defs"]:
+                            verb_def = self.schema["$defs"][verb_name]
+                            
+                            # Extract the actual verb name (lowercase)
+                            if "properties" in verb_def:
+                                prop_names = list(verb_def["properties"].keys())
+                                if prop_names:
+                                    actual_verb = prop_names[0]
+                                    verbs[actual_verb] = {
+                                        "name": actual_verb,
+                                        "schema_name": verb_name,
+                                        "definition": verb_def
+                                    }
+                                    print(f"Added verb: {actual_verb}")
+        else:
+            print(f"Missing $defs or SWMLMethod in schema")
+            if "$defs" in self.schema:
+                print(f"Available definitions: {list(self.schema['$defs'].keys())}")
+        
+        return verbs
+    
+    def get_verb_properties(self, verb_name: str) -> Dict[str, Any]:
+        """
+        Get the properties for a specific verb
+        
+        Args:
+            verb_name: The name of the verb (e.g., "ai", "answer", etc.)
+            
+        Returns:
+            The properties for the verb or an empty dict if not found
+        """
+        if verb_name in self.verbs:
+            verb_def = self.verbs[verb_name]["definition"]
+            if "properties" in verb_def and verb_name in verb_def["properties"]:
+                return verb_def["properties"][verb_name]
+        return {}
+    
+    def get_verb_required_properties(self, verb_name: str) -> List[str]:
+        """
+        Get the required properties for a specific verb
+        
+        Args:
+            verb_name: The name of the verb (e.g., "ai", "answer", etc.)
+            
+        Returns:
+            List of required property names for the verb or an empty list if not found
+        """
+        if verb_name in self.verbs:
+            verb_def = self.verbs[verb_name]["definition"]
+            if "properties" in verb_def and verb_name in verb_def["properties"]:
+                verb_props = verb_def["properties"][verb_name]
+                return verb_props.get("required", [])
+        return []
+    
+    def validate_verb(self, verb_name: str, verb_config: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Validate a verb configuration against the schema
+        
+        Args:
+            verb_name: The name of the verb (e.g., "ai", "answer", etc.)
+            verb_config: The configuration for the verb
+            
+        Returns:
+            (is_valid, error_messages) tuple
+        """
+        # Simple validation for now - can be enhanced with more complete JSON Schema validation
+        errors = []
+        
+        # Check if the verb exists in the schema
+        if verb_name not in self.verbs:
+            errors.append(f"Unknown verb: {verb_name}")
+            return False, errors
+            
+        # Get the required properties for this verb
+        required_props = self.get_verb_required_properties(verb_name)
+        
+        # Check if all required properties are present
+        for prop in required_props:
+            if prop not in verb_config:
+                errors.append(f"Missing required property '{prop}' for verb '{verb_name}'")
+                
+        # Return validation result
+        return len(errors) == 0, errors
+    
+    def get_all_verb_names(self) -> List[str]:
+        """
+        Get all verb names defined in the schema
+        
+        Returns:
+            List of verb names
+        """
+        return list(self.verbs.keys())
+        
+    def get_verb_parameters(self, verb_name: str) -> Dict[str, Any]:
+        """
+        Get the parameter definitions for a specific verb
+        
+        Args:
+            verb_name: The name of the verb (e.g., "ai", "answer", etc.)
+            
+        Returns:
+            Dictionary mapping parameter names to their definitions
+        """
+        properties = self.get_verb_properties(verb_name)
+        if "properties" in properties:
+            return properties["properties"]
+        return {}
+        
+    def generate_method_signature(self, verb_name: str) -> str:
+        """
+        Generate a Python method signature for a verb
+        
+        Args:
+            verb_name: The name of the verb
+            
+        Returns:
+            A Python method signature string
+        """
+        # Get the verb properties
+        verb_props = self.get_verb_properties(verb_name)
+        
+        # Get verb parameters
+        verb_params = self.get_verb_parameters(verb_name)
+        
+        # Get required parameters
+        required_params = self.get_verb_required_properties(verb_name)
+        
+        # Initialize method parameters
+        param_list = ["self"]
+        
+        # Add the parameters
+        for param_name, param_def in verb_params.items():
+            # Check if this is a required parameter
+            is_required = param_name in required_params
+            
+            # Determine parameter type annotation
+            param_type = self._get_type_annotation(param_def)
+            
+            # Add default value if not required
+            if is_required:
+                param_list.append(f"{param_name}: {param_type}")
+            else:
+                param_list.append(f"{param_name}: Optional[{param_type}] = None")
+        
+        # Add **kwargs at the end
+        param_list.append("**kwargs")
+        
+        # Generate method docstring
+        docstring = f'"""\n        Add the {verb_name} verb to the current document\n        \n'
+        
+        # Add parameter documentation
+        for param_name, param_def in verb_params.items():
+            description = param_def.get("description", "")
+            # Clean up the description for docstring
+            description = description.replace('\n', ' ').strip()
+            docstring += f"        Args:\n            {param_name}: {description}\n"
+            
+        # Add return documentation
+        docstring += f'        \n        Returns:\n            True if the verb was added successfully, False otherwise\n        """\n'
+        
+        # Create the full method signature with docstring
+        method_signature = f"def {verb_name}({', '.join(param_list)}) -> bool:\n{docstring}"
+        
+        return method_signature
+        
+    def generate_method_body(self, verb_name: str) -> str:
+        """
+        Generate the method body implementation for a verb
+        
+        Args:
+            verb_name: The name of the verb
+            
+        Returns:
+            The method body as a string
+        """
+        # Get verb parameters
+        verb_params = self.get_verb_parameters(verb_name)
+        
+        body = []
+        body.append("        # Prepare the configuration")
+        body.append("        config = {}")
+        
+        # Add handling for each parameter
+        for param_name in verb_params.keys():
+            body.append(f"        if {param_name} is not None:")
+            body.append(f"            config['{param_name}'] = {param_name}")
+            
+        # Add handling for kwargs
+        body.append("        # Add any additional parameters from kwargs")
+        body.append("        for key, value in kwargs.items():")
+        body.append("            if value is not None:")
+        body.append("                config[key] = value")
+        
+        # Add the call to add_verb
+        body.append("")
+        body.append(f"        # Add the {verb_name} verb")
+        body.append(f"        return self.add_verb('{verb_name}', config)")
+        
+        return "\n".join(body)
+    
+    def _get_type_annotation(self, param_def: Dict[str, Any]) -> str:
+        """
+        Get the Python type annotation for a parameter
+        
+        Args:
+            param_def: Parameter definition from the schema
+            
+        Returns:
+            Python type annotation as a string
+        """
+        schema_type = param_def.get("type")
+        
+        if schema_type == "string":
+            return "str"
+        elif schema_type == "integer":
+            return "int"
+        elif schema_type == "number":
+            return "float"
+        elif schema_type == "boolean":
+            return "bool"
+        elif schema_type == "array":
+            item_type = "Any"
+            if "items" in param_def:
+                item_def = param_def["items"]
+                item_type = self._get_type_annotation(item_def)
+            return f"List[{item_type}]"
+        elif schema_type == "object":
+            return "Dict[str, Any]"
+        else:
+            # Handle complex types or oneOf/anyOf
+            if "anyOf" in param_def or "oneOf" in param_def:
+                return "Any"
+            if "$ref" in param_def:
+                return "Any"  # Could be enhanced to resolve references
+            return "Any" 

signalwire_agents/utils/token_generators.py

@@ -0,0 +1,9 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+

signalwire_agents/utils/validators.py

@@ -0,0 +1,9 @@
+"""
+Copyright (c) 2025 SignalWire
+
+This file is part of the SignalWire AI Agents SDK.
+
+Licensed under the MIT License.
+See LICENSE file in the project root for full license information.
+"""
+

{signalwire_agents-0.1.1.dist-info → signalwire_agents-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.1
+Version: 0.1.5
 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.5.dist-info/RECORD

@@ -0,0 +1,34 @@
+signalwire_agents/__init__.py,sha256=NLgfrj90HmtMNumq43u16xWptlD-JrtXPNQVcwZ1yIo,800
+signalwire_agents/agent_server.py,sha256=se_YzOQE5UUoRUKCbTnOg9qr4G3qN7iVuQLutwXEwFU,12850
+signalwire_agents/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
+signalwire_agents/core/__init__.py,sha256=mVDLbpq1pg_WwiqsQR28NNZwJ6-VUXFIfg-vN7pk0ew,806
+signalwire_agents/core/agent_base.py,sha256=KIvueG5wIxveyALELISmPLWEkyhW5abU4hxq427ao_o,98466
+signalwire_agents/core/function_result.py,sha256=vD8eBDJBQNNnss1jShadfogCZw_prODB6eBkTuVgZKA,3538
+signalwire_agents/core/pom_builder.py,sha256=ywuiIfP8BeLBPo_G4X1teZlG6zTCMkW71CZnmyoDTAQ,6636
+signalwire_agents/core/swaig_function.py,sha256=WoHGQuCmU9L9k39pttRunmfRtIa_PnNRn9W0Xq3MfIk,6316
+signalwire_agents/core/swml_builder.py,sha256=Y_eHThVVso-_Hz4f73eEuu3HJstsM9PtBl-36GvAXhI,6594
+signalwire_agents/core/swml_handler.py,sha256=KvphI_YY47VWGVXaix_N3SuQSyygHEUr9We6xESQK44,7002
+signalwire_agents/core/swml_renderer.py,sha256=iobMWWoBR7dkHndI3Qlwf4C0fg2p7DmAU2Rb7ZmmLhA,13891
+signalwire_agents/core/swml_service.py,sha256=oZKM9pKPxtbsMp3nYnx5FXtW3igj2Sc2wZbQujNVNrg,42097
+signalwire_agents/core/security/__init__.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
+signalwire_agents/core/security/session_manager.py,sha256=5y0Mr3cI63cO34ctFgq-KX26mdG0Tpr7rTEsgoTS_44,5229
+signalwire_agents/core/state/__init__.py,sha256=qpYIfQBApet6VQsy6diS3yu0lMxCBC6REOUk5l1McUw,379
+signalwire_agents/core/state/file_state_manager.py,sha256=52I_KVlmhHCbKIaHj74Q-ksP_-AF6ewYmOXCf4n5DTQ,7307
+signalwire_agents/core/state/state_manager.py,sha256=76B4mDutMb826dK4c_IJhOXH09BW1bJu6EZa6Mh_LB4,2511
+signalwire_agents/prefabs/__init__.py,sha256=MW11J63XH7KxF2MWguRsMFM9iqMWexaEO9ynDPL_PDM,715
+signalwire_agents/prefabs/concierge.py,sha256=--esvAV1lozQGYXHAqvSg8_TtlIoVfQK75APJ5zqX9I,9779
+signalwire_agents/prefabs/faq_bot.py,sha256=cUuHhnDB8S4aVg-DiQe4jBmCAPrYQrND_Mff9iaeEa0,10572
+signalwire_agents/prefabs/info_gatherer.py,sha256=y9gxjq1vF0-TrE6m734dCcAHqxt0I_DyCqxoM45QY8U,9940
+signalwire_agents/prefabs/receptionist.py,sha256=Wb22igXTD8QK9lQVcJq88eIk7qQ2GSSIzSGuYyK-Dbk,10293
+signalwire_agents/prefabs/survey.py,sha256=1pyUeZ5heDqFAYqkYs5fHN_jQ7TKqJInnOOUQEajSsY,14358
+signalwire_agents/utils/__init__.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
+signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
+signalwire_agents/utils/schema_utils.py,sha256=LvFCFvJTQk_xYK0B-NXbkXKEF7Zmv-LqpV_vfpPnOb4,13473
+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.5.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
+signalwire_agents-0.1.5.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.5.dist-info/METADATA,sha256=BotyeNOQW27tW_uqJOiFFie06Ra77RYRx9SHO1FkJ-w,7414
+signalwire_agents-0.1.5.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+signalwire_agents-0.1.5.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.5.dist-info/RECORD,,

signalwire_agents-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-signalwire_agents/__init__.py,sha256=fOxVP6ME-O9x_nCGn9-VcssR7QnOD6cG6YlHP0dts4M,800
-signalwire_agents/agent_server.py,sha256=cyHVjsCSXHBVtJCB-eNgIPZNLKe-VT1fDFQR82TOkzY,12850
-signalwire_agents/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
-signalwire_agents-0.1.1.data/data/schema.json,sha256=M8Mn6pQda2P9jhbmkALrLr1wt-fRuhYRqdmEi9Rbhqk,178075
-signalwire_agents-0.1.1.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.1.dist-info/METADATA,sha256=yK8j3RqoCVO40A5MxR7UnGFCXCVJv7VS07-7WXQtbKw,7414
-signalwire_agents-0.1.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-signalwire_agents-0.1.1.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.1.dist-info/RECORD,,