signalwire-agents 0.1.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

signalwire_agents/prefabs/concierge.py

@@ -50,6 +50,8 @@ class ConciergeAgent(AgentBase):
         hours_of_operation: Optional[Dict[str, str]] = None,
         special_instructions: Optional[List[str]] = None,
         welcome_message: Optional[str] = None,
+        name: str = "concierge",
+        route: str = "/concierge",
         **kwargs
     ):
         """
@@ -62,12 +64,14 @@ class ConciergeAgent(AgentBase):
             hours_of_operation: Optional dictionary of operating hours
             special_instructions: Optional list of special instructions
             welcome_message: Optional custom welcome message
+            name: Agent name for the route
+            route: HTTP route for this agent
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
         super().__init__(
-            name="concierge",
-            route="/concierge",
+            name=name,
+            route=route,
             use_pom=True,
             **kwargs
         )

signalwire_agents/prefabs/info_gatherer.py

@@ -9,9 +9,12 @@ See LICENSE file in the project root for full license information.
 
 """
 InfoGathererAgent - Prefab agent for collecting answers to a series of questions
+
+Supports both static (questions provided at init) and dynamic (questions determined 
+by a callback function) configuration modes.
 """
 
-from typing import List, Dict, Any, Optional, Union
+from typing import List, Dict, Any, Optional, Union, Callable
 import json
 
 from signalwire_agents.core.agent_base import AgentBase
@@ -39,7 +42,7 @@ class InfoGathererAgent(AgentBase):
     
     def __init__(
         self,
-        questions: List[Dict[str, str]],
+        questions: Optional[List[Dict[str, str]]] = None,
         name: str = "info_gatherer", 
         route: str = "/info_gatherer",
         **kwargs
@@ -48,7 +51,8 @@ class InfoGathererAgent(AgentBase):
         Initialize an information gathering agent
         
         Args:
-            questions: List of questions to ask, each with:
+            questions: Optional list of questions to ask. If None, questions will be determined
+                      dynamically via a callback function. Each question dict should have:
                 - key_name: Identifier for storing the answer
                 - question_text: The actual question to ask the user
                 - confirm: (Optional) If set to True, the agent will confirm the answer before submitting
@@ -64,39 +68,84 @@ class InfoGathererAgent(AgentBase):
             **kwargs
         )
         
-        # Validate questions format
-        self._validate_questions(questions)
-        
-        # Set up global data with questions and initial state
-        self.set_global_data({
-            "questions": questions,
-            "question_index": 0,
-            "answers": []
-        })
+        # Store whether we're in static or dynamic mode
+        self._static_questions = questions
+        self._question_callback = None
         
-        # Build a minimal prompt
-        self._build_prompt()
+        if questions is not None:
+            # Static mode: validate questions and set up immediately
+            self._validate_questions(questions)
+            self.set_global_data({
+                "questions": questions,
+                "question_index": 0,
+                "answers": []
+            })
+            # Build prompt for static configuration
+            self._build_prompt()
+        else:
+            # Dynamic mode: questions will be set up via callback in on_swml_request
+            # Build a generic prompt
+            self._build_prompt("dynamic")
         
         # Configure additional agent settings
         self._configure_agent_settings()
     
+    def set_question_callback(self, callback: Callable[[dict, dict, dict], List[Dict[str, str]]]):
+        """
+        Set a callback function for dynamic question configuration
+        
+        Args:
+            callback: Function that takes (query_params, body_params, headers) and returns
+                     a list of question dictionaries. Each question dict should have:
+                     - key_name: Identifier for storing the answer
+                     - question_text: The actual question to ask the user
+                     - confirm: (Optional) If True, agent will confirm answer before submitting
+                     
+        Example:
+            def my_question_callback(query_params, body_params, headers):
+                question_set = query_params.get('set', 'default')
+                if question_set == 'support':
+                    return [
+                        {"key_name": "name", "question_text": "What is your name?"},
+                        {"key_name": "issue", "question_text": "What's the issue?"}
+                    ]
+                else:
+                    return [{"key_name": "name", "question_text": "What is your name?"}]
+            
+            agent.set_question_callback(my_question_callback)
+        """
+        self._question_callback = callback
+    
     def _validate_questions(self, questions):
         """Validate that questions are in the correct format"""
         if not questions:
             raise ValueError("At least one question is required")
             
+        if not isinstance(questions, list):
+            raise ValueError("Questions must be a list")
+            
         for i, question in enumerate(questions):
+            if not isinstance(question, dict):
+                raise ValueError(f"Question {i+1} must be a dictionary")
             if "key_name" not in question:
                 raise ValueError(f"Question {i+1} is missing 'key_name' field")
             if "question_text" not in question:
                 raise ValueError(f"Question {i+1} is missing 'question_text' field")
     
-    def _build_prompt(self):
+    def _build_prompt(self, mode="static"):
         """Build a minimal prompt with just the objective"""
-        self.prompt_add_section(
-            "Objective", 
-            body="Your role is to get answers to a series of questions. Begin by asking the user if they are ready to answer some questions. If they confirm they are ready, call the start_questions function to begin the process."
-        )
+        if mode == "dynamic":
+            # Generic prompt for dynamic mode - will be customized later
+            self.prompt_add_section(
+                "Objective", 
+                body="Your role is to gather information by asking questions. Begin by asking the user if they are ready to answer some questions. If they confirm they are ready, call the start_questions function to begin the process."
+            )
+        else:
+            # Original static prompt
+            self.prompt_add_section(
+                "Objective", 
+                body="Your role is to get answers to a series of questions. Begin by asking the user if they are ready to answer some questions. If they confirm they are ready, call the start_questions function to begin the process."
+            )
     
     def _configure_agent_settings(self):
         """Configure additional agent settings"""
@@ -106,6 +155,77 @@ class InfoGathererAgent(AgentBase):
             "speech_event_timeout": 1000  # Slightly longer for thoughtful responses
         })
     
+    def on_swml_request(self, request_data=None, callback_path=None, request=None):
+        """
+        Handle dynamic configuration using the callback function
+        
+        This method is called when SWML is requested and allows us to configure
+        the agent just-in-time using the provided callback.
+        """
+        # Only process if we're in dynamic mode (no static questions)
+        if self._static_questions is not None:
+            return None
+            
+        # If no callback is set, provide a basic fallback
+        if self._question_callback is None:
+            fallback_questions = [
+                {"key_name": "name", "question_text": "What is your name?"},
+                {"key_name": "message", "question_text": "How can I help you today?"}
+            ]
+            return {
+                "global_data": {
+                    "questions": fallback_questions,
+                    "question_index": 0,
+                    "answers": []
+                }
+            }
+        
+        # Extract request information for callback
+        query_params = {}
+        body_params = request_data or {}
+        headers = {}
+        
+        if request and hasattr(request, 'query_params'):
+            query_params = dict(request.query_params)
+        
+        if request and hasattr(request, 'headers'):
+            headers = dict(request.headers)
+        
+        try:
+            # Call the user-provided callback to get questions
+            print(f"Calling question callback with query_params: {query_params}")
+            questions = self._question_callback(query_params, body_params, headers)
+            print(f"Callback returned {len(questions)} questions")
+            
+            # Validate the returned questions
+            self._validate_questions(questions)
+            
+            # Return global data modifications
+            return {
+                "global_data": {
+                    "questions": questions,
+                    "question_index": 0,
+                    "answers": []
+                }
+            }
+            
+        except Exception as e:
+            # Log error and fall back to basic questions
+            print(f"Error in question callback: {e}")
+            fallback_questions = [
+                {"key_name": "name", "question_text": "What is your name?"},
+                {"key_name": "message", "question_text": "How can I help you today?"}
+            ]
+            return {
+                "global_data": {
+                    "questions": fallback_questions,
+                    "question_index": 0,
+                    "answers": []
+                }
+            }
+    
+
+    
     def _generate_question_instruction(self, question_text: str, needs_confirmation: bool, is_first_question: bool = False) -> str:
         """
         Generate the instruction text for asking a question
@@ -236,13 +356,11 @@ class InfoGathererAgent(AgentBase):
             # Create response with the global data update and next question
             result = SwaigFunctionResult(instruction)
             
-            # Add actions to update global data
-            result.add_actions([
-                {"set_global_data": {
-                    "answers": new_answers,
-                    "question_index": new_question_index
-                }}
-            ])
+            # Use the helper method to update global data
+            result.update_global_data({
+                "answers": new_answers,
+                "question_index": new_question_index
+            })
             
             return result
         else:
@@ -251,13 +369,11 @@ class InfoGathererAgent(AgentBase):
                 "Thank you! All questions have been answered. You can now summarize the information collected or ask if there's anything else the user would like to discuss."
             )
             
-            # Add actions to update global data
-            result.add_actions([
-                {"set_global_data": {
-                    "answers": new_answers,
-                    "question_index": new_question_index
-                }}
-            ])
+            # Use the helper method to update global data
+            result.update_global_data({
+                "answers": new_answers,
+                "question_index": new_question_index
+            })
             
             return result
 

signalwire_agents/prefabs/receptionist.py

@@ -40,7 +40,7 @@ class ReceptionistAgent(AgentBase):
         name: str = "receptionist", 
         route: str = "/receptionist",
         greeting: str = "Thank you for calling. How can I help you today?",
-        voice: str = "elevenlabs.josh",
+        voice: str = "rime.spore",
         **kwargs
     ):
         """
@@ -258,28 +258,20 @@ class ReceptionistAgent(AgentBase):
         # Get transfer number
         transfer_number = department.get("number", "")
         
-        # Create result with transfer SWML
-        result = SwaigFunctionResult(f"I'll transfer you to our {department_name} department now. Thank you for calling, {name}!")
+        # Create result with transfer using the connect helper method
+        # post_process=True allows the AI to speak the response before executing the transfer
+        result = SwaigFunctionResult(
+            f"I'll transfer you to our {department_name} department now. Thank you for calling, {name}!",
+            post_process=True
+        )
         
-        # Add the SWML to execute the transfer
-                    # Add actions to update global data
-        result.add_actions([
-            {
-                "SWML": {
-                    "sections": {
-                        "main": [
-                            {
-                                "connect": {
-                                    "to": transfer_number
-                                }
-                            }
-                        ]
-                    },
-                    "version": "1.0.0"
-                },
-                "transfer": "true"
-            }
-        ])
+        # Use the connect helper instead of manually constructing SWML
+        # final=True means this is a permanent transfer (call exits the agent)
+        result.connect(transfer_number, final=True)
+        
+        # Alternative: Immediate transfer without AI speaking (faster but less friendly)
+        # result = SwaigFunctionResult()  # No response text needed
+        # result.connect(transfer_number, final=True)  # Executes immediately from function call
         
         return result
         

signalwire_agents/prefabs/survey.py

@@ -60,6 +60,8 @@ class SurveyAgent(AgentBase):
         conclusion: Optional[str] = None,
         brand_name: Optional[str] = None,
         max_retries: int = 2,
+        name: str = "survey",
+        route: str = "/survey",
         **kwargs
     ):
         """
@@ -78,12 +80,14 @@ class SurveyAgent(AgentBase):
             conclusion: Optional custom conclusion message
             brand_name: Optional brand or company name
             max_retries: Maximum number of times to retry invalid answers
+            name: Name for the agent (default: "survey")
+            route: HTTP route for the agent (default: "/survey")
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
         super().__init__(
-            name="survey",
-            route="/survey",
+            name=name,
+            route=route,
             use_pom=True,
             **kwargs
         )