signalwire-agents 1.0.7__py3-none-any.whl → 1.0.17.dev4__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__ = "1.0.7"
+__version__ = "1.0.17.dev4"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase

signalwire_agents/agent_server.py

@@ -61,17 +61,28 @@ class AgentServer:
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="0.1.2",
+            version="1.0.17.dev4",
             redirect_slashes=False
         )
         
         # Keep track of registered agents
         self.agents: Dict[str, AgentBase] = {}
-        
+
         # Keep track of SIP routing configuration
         self._sip_routing_enabled = False
         self._sip_route = None
         self._sip_username_mapping: Dict[str, str] = {}  # Maps SIP usernames to routes
+
+        # Register health endpoints immediately so they're available
+        # whether using server.run() or server.app with gunicorn
+        self._register_health_endpoints()
+
+        # Register catch-all handler on startup (not in __init__) so it runs AFTER
+        # all other routes are registered. This ensures custom routes like /get_token
+        # don't get overshadowed by the catch-all /{full_path:path} route.
+        @self.app.on_event("startup")
+        async def _setup_catch_all():
+            self._register_catch_all_handler()
     
     def register(self, agent: AgentBase, route: Optional[str] = None) -> None:
         """
@@ -100,12 +111,12 @@ class AgentServer:
             
         # Store the agent
         self.agents[route] = agent
-        
+
         # Get the router and register it using the standard approach
         # The agent's router already handles both trailing slash versions properly
         router = agent.as_router()
         self.app.include_router(router, prefix=route)
-        
+
         self.logger.info(f"Registered agent '{agent.get_name()}' at route '{route}'")
         
         # If SIP routing is enabled and auto-mapping is on, register SIP usernames for this agent
@@ -519,13 +530,13 @@ class AgentServer:
         sys.stdout.flush()
         
         return response
-    
-    def _run_server(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
-        """Original server mode logic"""
-        if not self.agents:
-            self.logger.warning("Starting server with no registered agents")
-            
-        # Add a health check endpoint
+
+    def _register_health_endpoints(self) -> None:
+        """Register health and readiness endpoints.
+
+        Called during __init__ so endpoints are available whether using
+        server.run() or accessing server.app directly with gunicorn.
+        """
         @self.app.get("/health")
         def health_check():
             return {
@@ -533,66 +544,19 @@ class AgentServer:
                 "agents": len(self.agents),
                 "routes": list(self.agents.keys())
             }
-            
-        # Add catch-all route handler to handle both trailing slash and non-trailing slash versions
-        @self.app.get("/{full_path:path}")
-        @self.app.post("/{full_path:path}")
-        async def handle_all_routes(request: Request, full_path: str):
-            """Handle requests that don't match registered routes (e.g. /matti instead of /matti/)"""
-            # Check if this path maps to one of our registered agents
-            for route, agent in self.agents.items():
-                # Check for exact match with registered route
-                if full_path == route.lstrip("/"):
-                    # This is a request to an agent's root without trailing slash
-                    return await agent._handle_root_request(request)
-                elif full_path.startswith(route.lstrip("/") + "/"):
-                    # This is a request to an agent's sub-path
-                    relative_path = full_path[len(route.lstrip("/")):]
-                    relative_path = relative_path.lstrip("/")
-
-                    # Route to appropriate handler based on path
-                    if not relative_path or relative_path == "/":
-                        return await agent._handle_root_request(request)
 
-                    clean_path = relative_path.rstrip("/")
-                    if clean_path == "debug":
-                        return await agent._handle_debug_request(request)
-                    elif clean_path == "swaig":
-                        from fastapi import Response
-                        return await agent._handle_swaig_request(request, Response())
-                    elif clean_path == "post_prompt":
-                        return await agent._handle_post_prompt_request(request)
-                    elif clean_path == "check_for_input":
-                        return await agent._handle_check_for_input_request(request)
-
-                    # Check for custom routing callbacks
-                    if hasattr(agent, '_routing_callbacks'):
-                        for callback_path, callback_fn in agent._routing_callbacks.items():
-                            cb_path_clean = callback_path.strip("/")
-                            if clean_path == cb_path_clean:
-                                request.state.callback_path = callback_path
-                                return await agent._handle_root_request(request)
+        @self.app.get("/ready")
+        def readiness_check():
+            return {
+                "status": "ready",
+                "agents": len(self.agents)
+            }
 
-            # No matching agent - check for static files
-            if hasattr(self, '_static_directories'):
-                # Check each static directory route
-                for static_route, static_dir in self._static_directories.items():
-                    # For root static route, serve any unmatched path
-                    if static_route == "" or static_route == "/":
-                        response = self._serve_static_file(full_path, "")
-                        if response:
-                            return response
-                    # For prefixed static routes, check if path matches
-                    elif full_path.startswith(static_route.lstrip("/") + "/") or full_path == static_route.lstrip("/"):
-                        relative_path = full_path[len(static_route.lstrip("/")):].lstrip("/")
-                        response = self._serve_static_file(relative_path, static_route)
-                        if response:
-                            return response
+    def _run_server(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
+        """Original server mode logic"""
+        if not self.agents:
+            self.logger.warning("Starting server with no registered agents")
 
-            # No matching agent or static file found
-            from fastapi import HTTPException
-            raise HTTPException(status_code=404, detail="Not Found")
-            
         # Set host and port
         host = host or self.host
         port = port or self.port
@@ -722,6 +686,7 @@ class AgentServer:
 
         self.logger.info(f"Serving static files from '{directory}' at route '{route or '/'}'")
 
+
     def _serve_static_file(self, file_path: str, route: str = "/") -> Optional[Response]:
         """
         Internal method to serve a static file.
@@ -769,3 +734,73 @@ class AgentServer:
             return None
 
         return FileResponse(full_path)
+
+    def _register_catch_all_handler(self) -> None:
+        """
+        Register catch-all route handler for agent routing and static files.
+
+        This handler is needed for:
+        1. Routing requests without trailing slashes to agents (e.g., /santa instead of /santa/)
+        2. Serving static files from directories registered with serve_static_files()
+
+        Called via startup event (not __init__) to ensure it runs AFTER all other routes
+        are registered. This prevents the catch-all from overshadowing custom routes
+        like /get_token that users may add to server.app.
+        """
+        @self.app.get("/{full_path:path}")
+        @self.app.post("/{full_path:path}")
+        async def handle_all_routes(request: Request, full_path: str):
+            """Handle requests that don't match registered routes (e.g. /matti instead of /matti/)"""
+            # Check if this path maps to one of our registered agents
+            for route, agent in self.agents.items():
+                # Check for exact match with registered route
+                if full_path == route.lstrip("/"):
+                    # This is a request to an agent's root without trailing slash
+                    return await agent._handle_root_request(request)
+                elif full_path.startswith(route.lstrip("/") + "/"):
+                    # This is a request to an agent's sub-path
+                    relative_path = full_path[len(route.lstrip("/")):]
+                    relative_path = relative_path.lstrip("/")
+
+                    # Route to appropriate handler based on path
+                    if not relative_path or relative_path == "/":
+                        return await agent._handle_root_request(request)
+
+                    clean_path = relative_path.rstrip("/")
+                    if clean_path == "debug":
+                        return await agent._handle_debug_request(request)
+                    elif clean_path == "swaig":
+                        from fastapi import Response
+                        return await agent._handle_swaig_request(request, Response())
+                    elif clean_path == "post_prompt":
+                        return await agent._handle_post_prompt_request(request)
+                    elif clean_path == "check_for_input":
+                        return await agent._handle_check_for_input_request(request)
+
+                    # Check for custom routing callbacks
+                    if hasattr(agent, '_routing_callbacks'):
+                        for callback_path, callback_fn in agent._routing_callbacks.items():
+                            cb_path_clean = callback_path.strip("/")
+                            if clean_path == cb_path_clean:
+                                request.state.callback_path = callback_path
+                                return await agent._handle_root_request(request)
+
+            # No matching agent - check for static files
+            if hasattr(self, '_static_directories'):
+                # Check each static directory route
+                for static_route, static_dir in self._static_directories.items():
+                    # For root static route, serve any unmatched path
+                    if static_route == "" or static_route == "/":
+                        response = self._serve_static_file(full_path, "")
+                        if response:
+                            return response
+                    # For prefixed static routes, check if path matches
+                    elif full_path.startswith(static_route.lstrip("/") + "/") or full_path == static_route.lstrip("/"):
+                        relative_path = full_path[len(static_route.lstrip("/")):].lstrip("/")
+                        response = self._serve_static_file(relative_path, static_route)
+                        if response:
+                            return response
+
+            # No matching agent or static file found
+            from fastapi import HTTPException
+            raise HTTPException(status_code=404, detail="Not Found")