signalwire-agents 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

signalwire_agents/core/swml_service.py

@@ -1,3 +1,12 @@
+"""
+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.
+"""
+
 """
 SWMLService - Base class for SWML document creation and serving
 
@@ -167,8 +176,8 @@ class SWMLService:
         # Create auto-vivified methods for all verbs
         self._create_verb_methods()
         
-        # Initialize routing callback
-        self._routing_callback = None
+        # Initialize routing callbacks dictionary (path -> callback)
+        self._routing_callbacks = {}
     
     def _create_verb_methods(self) -> None:
         """
@@ -352,8 +361,14 @@ class SWMLService:
             import importlib.resources
             try:
                 # Python 3.9+
-                with importlib.resources.files("signalwire_agents").joinpath("schema.json") as path:
+                try:
+                    # Python 3.13+
+                    path = importlib.resources.files("signalwire_agents").joinpath("schema.json")
                     return str(path)
+                except Exception:
+                    # Python 3.9-3.12
+                    with importlib.resources.files("signalwire_agents").joinpath("schema.json") as path:
+                        return str(path)
             except AttributeError:
                 # Python 3.7-3.8
                 with importlib.resources.path("signalwire_agents", "schema.json") as path:
@@ -566,34 +581,47 @@ class SWMLService:
             """Handle GET/POST requests to the root endpoint with trailing slash"""
             return await self._handle_request(request, response)
         
-        # Add SIP endpoint if routing callback is configured
-        if self._routing_callback is not None:
-            # SIP endpoint - without trailing slash
-            @router.get("/sip")
-            @router.post("/sip")
-            async def handle_sip_no_slash(request: Request, response: Response):
-                """Handle GET/POST requests to the SIP endpoint"""
-                return await self._handle_request(request, response)
-                
-            # SIP endpoint - with trailing slash
-            @router.get("/sip/")
-            @router.post("/sip/")
-            async def handle_sip_with_slash(request: Request, response: Response):
-                """Handle GET/POST requests to the SIP endpoint with trailing slash"""
-                return await self._handle_request(request, response)
-                
-            self.log.info("sip_endpoint_registered", path="/sip")
+        # Add endpoints for all registered routing callbacks
+        if hasattr(self, '_routing_callbacks') and self._routing_callbacks:
+            for callback_path, callback_fn in self._routing_callbacks.items():
+                # Skip the root path as it's already handled
+                if callback_path == "/":
+                    continue
+                    
+                # Register the endpoint without trailing slash
+                @router.get(callback_path)
+                @router.post(callback_path)
+                async def handle_callback_no_slash(request: Request, response: Response, cb_path=callback_path):
+                    """Handle GET/POST requests to a registered callback path"""
+                    # Store the callback path in request state for _handle_request to use
+                    request.state.callback_path = cb_path
+                    return await self._handle_request(request, response)
+                    
+                # Register the endpoint with trailing slash if it doesn't already have one
+                if not callback_path.endswith('/'):
+                    slash_path = f"{callback_path}/"
+                    
+                    @router.get(slash_path)
+                    @router.post(slash_path)
+                    async def handle_callback_with_slash(request: Request, response: Response, cb_path=callback_path):
+                        """Handle GET/POST requests to a registered callback path with trailing slash"""
+                        # Store the callback path in request state for _handle_request to use
+                        request.state.callback_path = cb_path
+                        return await self._handle_request(request, response)
+                        
+                self.log.info("callback_endpoint_registered", path=callback_path)
         
         self._router = router
         return router
     
-    def register_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]]) -> None:
+    def register_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]], 
+                                path: str = "/sip") -> None:
         """
         Register a callback function that will be called to determine routing
         based on POST data.
         
-        When a routing callback is registered, a global `/sip` endpoint is automatically
-        created that will handle SIP requests. This endpoint will use the callback to
+        When a routing callback is registered, an endpoint at the specified path is automatically
+        created that will handle requests. This endpoint will use the callback to
         determine if the request should be processed by this service or redirected.
         
         The callback should take a request object and request body dictionary and return:
@@ -602,9 +630,15 @@ class SWMLService:
         
         Args:
             callback_fn: The callback function to register
+            path: The path where this callback should be registered (default: "/sip")
         """
-        self.log.info("registering_routing_callback")
-        self._routing_callback = callback_fn
+        # Normalize the path to ensure consistent lookup
+        normalized_path = path.rstrip("/")
+        if not normalized_path.startswith("/"):
+            normalized_path = f"/{normalized_path}"
+            
+        self.log.info("registering_routing_callback", path=normalized_path)
+        self._routing_callbacks[normalized_path] = callback_fn
 
     @staticmethod
     def extract_sip_username(request_body: Dict[str, Any]) -> Optional[str]:
@@ -662,6 +696,9 @@ class SWMLService:
             response.headers["WWW-Authenticate"] = "Basic"
             return HTTPException(status_code=401, detail="Unauthorized")
         
+        # Get callback path from request state
+        callback_path = getattr(request.state, "callback_path", None)
+        
         # Process request body if it's a POST
         body = {}
         if request.method == "POST":
@@ -670,25 +707,33 @@ class SWMLService:
                 if raw_body:
                     body = await request.json()
                     
-                    # Check if we have a routing callback and should reroute the request
-                    if self._routing_callback is not None:
-                        self.log.debug("checking_routing", body_keys=list(body.keys()))
-                        route = self._routing_callback(request, body)
+                    # Check if this is a callback path and we have a callback registered for it
+                    if callback_path and hasattr(self, '_routing_callbacks') and callback_path in self._routing_callbacks:
+                        callback_fn = self._routing_callbacks[callback_path]
+                        self.log.debug("checking_routing", 
+                                      path=callback_path, 
+                                      body_keys=list(body.keys()))
                         
-                        if route is not None:
-                            self.log.info("routing_request", route=route)
-                            # We should return a redirect to the new route
-                            # Use 307 to preserve the POST method and its body
-                            response = Response(status_code=307)
-                            response.headers["Location"] = route
-                            return response
+                        # Call the callback function
+                        try:
+                            route = callback_fn(request, body)
+                            
+                            if route is not None:
+                                self.log.info("routing_request", route=route)
+                                # We should return a redirect to the new route
+                                # Use 307 to preserve the POST method and its body
+                                response = Response(status_code=307)
+                                response.headers["Location"] = route
+                                return response
+                        except Exception as e:
+                            self.log.error("error_in_routing_callback", error=str(e))
             except Exception as e:
                 self.log.error("error_parsing_body", error=str(e))
                 # Continue with empty body if parsing fails
                 pass
         
         # Allow for customized handling in subclasses
-        modifications = self.on_request(body)
+        modifications = self.on_request(body, callback_path)
         
         # Apply any modifications if needed
         if modifications and isinstance(modifications, dict):
@@ -711,7 +756,7 @@ class SWMLService:
         # Return the SWML document
         return Response(content=swml, media_type="application/json")
     
-    def on_request(self, request_data: Optional[dict] = None) -> Optional[dict]:
+    def on_request(self, request_data: Optional[dict] = None, callback_path: Optional[str] = None) -> Optional[dict]:
         """
         Called when SWML is requested, with request data when available
         
@@ -719,6 +764,7 @@ class SWMLService:
         
         Args:
             request_data: Optional dictionary containing the parsed POST body
+            callback_path: Optional callback path
             
         Returns:
             Optional dict to modify/augment the SWML document
@@ -787,8 +833,10 @@ class SWMLService:
         print(f"Basic Auth: {username}:{password}")
         
         # Check if SIP routing is enabled and print additional info
-        if self._routing_callback is not None:
-            print(f"SIP endpoint: {protocol}://{display_host}/sip")
+        if self._routing_callbacks:
+            print(f"Callback endpoints:")
+            for path in self._routing_callbacks:
+                print(f"{protocol}://{display_host}{path}")
         
         # Start uvicorn with or without SSL
         if self.ssl_enabled and ssl_cert_path and ssl_key_path:

signalwire_agents/prefabs/__init__.py

@@ -1,3 +1,12 @@
+"""
+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.
+"""
+
 """
 Prefab agents with specific functionality that can be used out-of-the-box
 """
@@ -6,10 +15,12 @@ from signalwire_agents.prefabs.info_gatherer import InfoGathererAgent
 from signalwire_agents.prefabs.faq_bot import FAQBotAgent
 from signalwire_agents.prefabs.concierge import ConciergeAgent
 from signalwire_agents.prefabs.survey import SurveyAgent
+from signalwire_agents.prefabs.receptionist import ReceptionistAgent
 
 __all__ = [
     "InfoGathererAgent",
     "FAQBotAgent",
     "ConciergeAgent",
-    "SurveyAgent"
+    "SurveyAgent",
+    "ReceptionistAgent"
 ]

signalwire_agents/prefabs/concierge.py

@@ -1,3 +1,12 @@
+"""
+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.
+"""
+
 """
 ConciergeAgent - Prefab agent for providing virtual concierge services
 """
@@ -41,7 +50,6 @@ class ConciergeAgent(AgentBase):
         hours_of_operation: Optional[Dict[str, str]] = None,
         special_instructions: Optional[List[str]] = None,
         welcome_message: Optional[str] = None,
-        schema_path: Optional[str] = None,
         **kwargs
     ):
         """
@@ -54,30 +62,13 @@ class ConciergeAgent(AgentBase):
             hours_of_operation: Optional dictionary of operating hours
             special_instructions: Optional list of special instructions
             welcome_message: Optional custom welcome message
-            schema_path: Optional path to a custom schema
             **kwargs: Additional arguments for AgentBase
         """
-        # Find schema.json if not provided
-        if not schema_path:
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            parent_dir = os.path.dirname(os.path.dirname(current_dir))
-            
-            schema_locations = [
-                os.path.join(current_dir, "schema.json"),
-                os.path.join(parent_dir, "schema.json")
-            ]
-            
-            for loc in schema_locations:
-                if os.path.exists(loc):
-                    schema_path = loc
-                    break
-                    
         # Initialize the base agent
         super().__init__(
             name="concierge",
             route="/concierge",
             use_pom=True,
-            schema_path=schema_path,
             **kwargs
         )
         

signalwire_agents/prefabs/faq_bot.py

@@ -1,3 +1,12 @@
+"""
+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.
+"""
+
 """
 FAQBotAgent - Prefab agent for answering frequently asked questions
 """
@@ -42,7 +51,6 @@ class FAQBotAgent(AgentBase):
         persona: Optional[str] = None,
         name: str = "faq_bot",
         route: str = "/faq",
-        schema_path: Optional[str] = None,
         **kwargs
     ):
         """
@@ -57,30 +65,13 @@ class FAQBotAgent(AgentBase):
             persona: Optional custom personality description
             name: Agent name for the route
             route: HTTP route for this agent
-            schema_path: Optional path to a custom schema
             **kwargs: Additional arguments for AgentBase
         """
-        # Find schema.json if not provided
-        if not schema_path:
-            current_dir = os.path.dirname(os.path.abspath(__file__))
-            parent_dir = os.path.dirname(os.path.dirname(current_dir))
-            
-            schema_locations = [
-                os.path.join(current_dir, "schema.json"),
-                os.path.join(parent_dir, "schema.json")
-            ]
-            
-            for loc in schema_locations:
-                if os.path.exists(loc):
-                    schema_path = loc
-                    break
-                    
         # Initialize the base agent
         super().__init__(
             name=name,
             route=route,
             use_pom=True,
-            schema_path=schema_path,
             **kwargs
         )