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

signalwire_agents/core/data_map.py

@@ -257,7 +257,6 @@ class DataMap:
         
         Args:
             foreach_config: Either:
-                - String: JSON path to array in response (deprecated, kept for compatibility)
                 - Dict: Foreach configuration with keys:
                     - input_key: Key in API response containing the array
                     - output_key: Name for the built string variable
@@ -278,20 +277,7 @@ class DataMap:
         if not self._webhooks:
             raise ValueError("Must add webhook before setting foreach")
             
-        if isinstance(foreach_config, str):
-            # Legacy support - convert string to basic foreach config
-            # Extract the key from "${response.key}" format if present
-            if foreach_config.startswith("${response.") and foreach_config.endswith("}"):
-                key = foreach_config[12:-1]  # Remove "${response." and "}"
-            else:
-                key = foreach_config
-            
-            foreach_data = {
-                "input_key": key,
-                "output_key": "foreach_output",
-                "append": "${this}"
-            }
-        else:
+        if isinstance(foreach_config, dict):
             # New format - validate required keys
             required_keys = ["input_key", "output_key", "append"]
             missing_keys = [key for key in required_keys if key not in foreach_config]
@@ -299,6 +285,8 @@ class DataMap:
                 raise ValueError(f"foreach config missing required keys: {missing_keys}")
             
             foreach_data = foreach_config
+        else:
+            raise ValueError("foreach_config must be a dictionary")
             
         self._webhooks[-1]["foreach"] = foreach_data
         return self

signalwire_agents/core/skill_manager.py

@@ -134,13 +134,6 @@ class SkillManager:
         if skill_identifier in self.loaded_skills:
             instance_key = skill_identifier
             skill_instance = self.loaded_skills[skill_identifier]
-        else:
-            # Try to find by skill name (for backwards compatibility)
-            for key, instance in self.loaded_skills.items():
-                if instance.SKILL_NAME == skill_identifier:
-                    instance_key = key
-                    skill_instance = instance
-                    break
         
         if skill_instance is None:
             self.logger.warning(f"Skill '{skill_identifier}' is not loaded")
@@ -173,11 +166,6 @@ class SkillManager:
         if skill_identifier in self.loaded_skills:
             return True
         
-        # Try to find by skill name (for backwards compatibility)
-        for instance in self.loaded_skills.values():
-            if instance.SKILL_NAME == skill_identifier:
-                return True
-        
         return False
     
     def get_skill(self, skill_identifier: str) -> Optional[SkillBase]:
@@ -194,9 +182,4 @@ class SkillManager:
         if skill_identifier in self.loaded_skills:
             return self.loaded_skills[skill_identifier]
         
-        # Try to find by skill name (for backwards compatibility)
-        for instance in self.loaded_skills.values():
-            if instance.SKILL_NAME == skill_identifier:
-                return instance
-        
         return None 

signalwire_agents/core/swaig_function.py

@@ -179,5 +179,3 @@ class SWAIGFunction:
             
         return function_def
 
-# Add an alias for backward compatibility
-SwaigFunction = SWAIGFunction

signalwire_agents/core/swml_builder.py

@@ -14,6 +14,7 @@ This module provides a fluent builder API for creating SWML documents.
 It allows for chaining method calls to build up a document step by step.
 """
 
+import types
 from typing import Dict, List, Any, Optional, Union, TypeVar
 try:
     from typing import Self  # Python 3.11+
@@ -43,6 +44,12 @@ class SWMLBuilder:
             service: The SWMLService to delegate to
         """
         self.service = service
+        
+        # Dictionary to cache dynamically created methods
+        self._verb_methods_cache = {}
+        
+        # Create auto-vivified methods for all verbs
+        self._create_verb_methods()
     
     def answer(self, max_duration: Optional[int] = None, codecs: Optional[str] = None) -> Self:
         """
@@ -55,7 +62,12 @@ class SWMLBuilder:
         Returns:
             Self for method chaining
         """
-        self.service.add_answer_verb(max_duration, codecs)
+        config = {}
+        if max_duration is not None:
+            config["max_duration"] = max_duration
+        if codecs is not None:
+            config["codecs"] = codecs
+        self.service.add_verb("answer", config)
         return self
     
     def hangup(self, reason: Optional[str] = None) -> Self:
@@ -68,7 +80,10 @@ class SWMLBuilder:
         Returns:
             Self for method chaining
         """
-        self.service.add_hangup_verb(reason)
+        config = {}
+        if reason is not None:
+            config["reason"] = reason
+        self.service.add_verb("hangup", config)
         return self
     
     def ai(self, 
@@ -92,14 +107,26 @@ class SWMLBuilder:
         Returns:
             Self for method chaining
         """
-        self.service.add_ai_verb(
-            prompt_text=prompt_text,
-            prompt_pom=prompt_pom,
-            post_prompt=post_prompt,
-            post_prompt_url=post_prompt_url,
-            swaig=swaig,
-            **kwargs
-        )
+        config = {}
+        
+        # Handle prompt (either text or POM, but not both)
+        if prompt_text is not None:
+            config["prompt"] = prompt_text
+        elif prompt_pom is not None:
+            config["prompt"] = prompt_pom
+        
+        # Add optional parameters
+        if post_prompt is not None:
+            config["post_prompt"] = post_prompt
+        if post_prompt_url is not None:
+            config["post_prompt_url"] = post_prompt_url
+        if swaig is not None:
+            config["SWAIG"] = swaig
+        
+        # Add any additional kwargs
+        config.update(kwargs)
+        
+        self.service.add_verb("ai", config)
         return self
     
     def play(self, url: Optional[str] = None, urls: Optional[List[str]] = None, 
@@ -215,4 +242,173 @@ class SWMLBuilder:
             Self for method chaining
         """
         self.service.reset_document()
-        return self 
+        return self
+    
+    def _create_verb_methods(self) -> None:
+        """
+        Create auto-vivified methods for all verbs at initialization time
+        
+        This creates methods for all SWML verbs defined in the schema,
+        allowing for fluent chaining like builder.denoise().goto().play()
+        """
+        # Get all verb names from the schema
+        if not hasattr(self.service, 'schema_utils') or not self.service.schema_utils:
+            return
+            
+        verb_names = self.service.schema_utils.get_all_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):
+                continue
+            
+            # Handle sleep verb specially since it takes an integer directly
+            if verb_name == "sleep":
+                def sleep_method(self_instance, duration=None, **kwargs):
+                    """
+                    Add the sleep verb to the document.
+                    
+                    Args:
+                        duration: The amount of time to sleep in milliseconds
+                    """
+                    # Sleep verb takes a direct integer parameter in SWML
+                    if duration is not None:
+                        self_instance.service.add_verb("sleep", duration)
+                    elif kwargs:
+                        # Try to get the value from kwargs
+                        self_instance.service.add_verb("sleep", next(iter(kwargs.values())))
+                    else:
+                        raise TypeError("sleep() missing required argument: 'duration'")
+                    return self_instance
+                
+                # Set it as an attribute of self
+                setattr(self, verb_name, types.MethodType(sleep_method, self))
+                
+                # Also cache it for later
+                self._verb_methods_cache[verb_name] = sleep_method
+                continue
+                
+            # Generate the method implementation for normal verbs
+            def make_verb_method(name):
+                def verb_method(self_instance, **kwargs):
+                    """
+                    Dynamically generated method for SWML verb - returns self for chaining
+                    """
+                    config = {}
+                    for key, value in kwargs.items():
+                        if value is not None:
+                            config[key] = value
+                    self_instance.service.add_verb(name, config)
+                    return self_instance
+                
+                # Add docstring to the method
+                if hasattr(self.service.schema_utils, 'get_verb_properties'):
+                    verb_properties = self.service.schema_utils.get_verb_properties(name)
+                    if "description" in verb_properties:
+                        verb_method.__doc__ = f"Add the {name} verb to the document.\n\n{verb_properties['description']}\n\nReturns: Self for method chaining"
+                    else:
+                        verb_method.__doc__ = f"Add the {name} verb to the document.\n\nReturns: Self for method chaining"
+                else:
+                    verb_method.__doc__ = f"Add the {name} verb to the document.\n\nReturns: Self for method chaining"
+                
+                return verb_method
+            
+            # Create the method with closure over the verb name
+            method = make_verb_method(verb_name)
+            
+            # Set it as an attribute of self
+            setattr(self, verb_name, types.MethodType(method, self))
+            
+            # Also cache it for later
+            self._verb_methods_cache[verb_name] = method
+    
+    def __getattr__(self, name: str) -> Any:
+        """
+        Dynamically generate and return SWML verb methods when accessed
+        
+        This method is called when an attribute lookup fails through the normal
+        mechanisms. It checks if the attribute name corresponds to a SWML verb
+        defined in the schema, and if so, dynamically creates a method for that verb.
+        
+        Args:
+            name: The name of the attribute being accessed
+            
+        Returns:
+            The dynamically created verb method if name is a valid SWML verb,
+            otherwise raises AttributeError
+            
+        Raises:
+            AttributeError: If name is not a valid SWML verb
+        """
+        # First check if this is a valid SWML verb
+        if not hasattr(self.service, 'schema_utils') or not self.service.schema_utils:
+            msg = f"'{self.__class__.__name__}' object has no attribute '{name}' (no schema available)"
+            raise AttributeError(msg)
+            
+        verb_names = self.service.schema_utils.get_all_verb_names()
+        
+        if name in verb_names:
+            # 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:
+                return types.MethodType(self._verb_methods_cache[name], self)
+            
+            # Handle sleep verb specially since it takes an integer directly
+            if name == "sleep":
+                def sleep_method(self_instance, duration=None, **kwargs):
+                    """
+                    Add the sleep verb to the document.
+                    
+                    Args:
+                        duration: The amount of time to sleep in milliseconds
+                    """
+                    # Sleep verb takes a direct integer parameter in SWML
+                    if duration is not None:
+                        self_instance.service.add_verb("sleep", duration)
+                    elif kwargs:
+                        # Try to get the value from kwargs
+                        self_instance.service.add_verb("sleep", next(iter(kwargs.values())))
+                    else:
+                        raise TypeError("sleep() missing required argument: 'duration'")
+                    return self_instance
+                
+                # Cache the method for future use
+                self._verb_methods_cache[name] = sleep_method
+                
+                # Return the bound method
+                return types.MethodType(sleep_method, self)
+            
+            # Generate the method implementation for normal verbs
+            def verb_method(self_instance, **kwargs):
+                """
+                Dynamically generated method for SWML verb - returns self for chaining
+                """
+                config = {}
+                for key, value in kwargs.items():
+                    if value is not None:
+                        config[key] = value
+                self_instance.service.add_verb(name, config)
+                return self_instance
+            
+            # Add docstring to the method
+            if hasattr(self.service.schema_utils, 'get_verb_properties'):
+                verb_properties = self.service.schema_utils.get_verb_properties(name)
+                if "description" in verb_properties:
+                    verb_method.__doc__ = f"Add the {name} verb to the document.\n\n{verb_properties['description']}\n\nReturns: Self for method chaining"
+                else:
+                    verb_method.__doc__ = f"Add the {name} verb to the document.\n\nReturns: Self for method chaining"
+            else:
+                verb_method.__doc__ = f"Add the {name} verb to the document.\n\nReturns: Self for method chaining"
+            
+            # Cache the method for future use
+            self._verb_methods_cache[name] = verb_method
+            
+            # Return the bound method
+            return types.MethodType(verb_method, self)
+        
+        # Not a valid verb
+        msg = f"'{self.__class__.__name__}' object has no attribute '{name}'"
+        raise AttributeError(msg)