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

signalwire_agents/__init__.py

@@ -14,13 +14,139 @@ SignalWire AI Agents SDK
 A package for building AI agents using SignalWire's AI and SWML capabilities.
 """
 
-__version__ = "0.1.6"
+# Configure logging before any other imports to ensure early initialization
+from .core.logging_config import configure_logging
+configure_logging()
+
+__version__ = "1.0.7"
 
 # Import core classes for easier access
-from signalwire_agents.core.agent_base import AgentBase
+from .core.agent_base import AgentBase
+from .core.contexts import ContextBuilder, Context, Step, create_simple_context
+from .core.data_map import DataMap, create_simple_api_tool, create_expression_tool
 from signalwire_agents.agent_server import AgentServer
 from signalwire_agents.core.swml_service import SWMLService
 from signalwire_agents.core.swml_builder import SWMLBuilder
-from signalwire_agents.core.state import StateManager, FileStateManager
+from signalwire_agents.core.function_result import SwaigFunctionResult
+from signalwire_agents.core.swaig_function import SWAIGFunction
+from signalwire_agents.agents.bedrock import BedrockAgent
+
+# Import WebService for static file serving
+from signalwire_agents.web import WebService
+
+# Lazy import skills to avoid slow startup for CLI tools
+# Skills are now loaded on-demand when requested
+def _get_skill_registry():
+    """Lazy import and return skill registry"""
+    import signalwire_agents.skills
+    return signalwire_agents.skills.skill_registry
+
+# Lazy import convenience functions from the CLI (if available)
+def start_agent(*args, **kwargs):
+    """Start an agent (lazy import)"""
+    try:
+        from signalwire_agents.cli.helpers import start_agent as _start_agent
+        return _start_agent(*args, **kwargs)
+    except ImportError:
+        raise NotImplementedError("CLI helpers not available")
+
+def run_agent(*args, **kwargs):
+    """Run an agent (lazy import)"""
+    try:
+        from signalwire_agents.cli.helpers import run_agent as _run_agent
+        return _run_agent(*args, **kwargs)
+    except ImportError:
+        raise NotImplementedError("CLI helpers not available")
+
+def list_skills(*args, **kwargs):
+    """List available skills (lazy import)"""
+    try:
+        from signalwire_agents.cli.helpers import list_skills as _list_skills
+        return _list_skills(*args, **kwargs)
+    except ImportError:
+        raise NotImplementedError("CLI helpers not available")
+
+def list_skills_with_params():
+    """
+    Get complete schema for all available skills including parameter metadata
+    
+    This function returns a comprehensive schema for all available skills,
+    including their metadata and parameter definitions. This is useful for
+    GUI configuration tools, API documentation, or programmatic skill discovery.
+    
+    Returns:
+        Dict[str, Dict[str, Any]]: Complete skill schema where keys are skill names
+        
+    Example:
+        >>> schema = list_skills_with_params()
+        >>> print(schema['web_search']['parameters']['api_key'])
+        {
+            'type': 'string',
+            'description': 'Google Custom Search API key',
+            'required': True,
+            'hidden': True,
+            'env_var': 'GOOGLE_SEARCH_API_KEY'
+        }
+    """
+    from signalwire_agents.skills.registry import skill_registry
+    return skill_registry.get_all_skills_schema()
+
+def register_skill(skill_class):
+    """
+    Register a custom skill class
+    
+    This allows third-party code to register skill classes directly without
+    requiring them to be in a specific directory structure.
+    
+    Args:
+        skill_class: A class that inherits from SkillBase
+        
+    Example:
+        >>> from my_custom_skills import MyWeatherSkill
+        >>> register_skill(MyWeatherSkill)
+        >>> # Now you can use it in agents:
+        >>> agent.add_skill('my_weather')
+    """
+    from signalwire_agents.skills.registry import skill_registry
+    return skill_registry.register_skill(skill_class)
+
+def add_skill_directory(path):
+    """
+    Add a directory to search for skills
+    
+    This allows third-party skill collections to be registered by path.
+    Skills in these directories should follow the same structure as built-in skills.
+    
+    Args:
+        path: Path to directory containing skill subdirectories
+        
+    Example:
+        >>> add_skill_directory('/opt/custom_skills')
+        >>> # Now agent.add_skill('my_custom_skill') will search in this directory
+    """
+    from signalwire_agents.skills.registry import skill_registry
+    return skill_registry.add_skill_directory(path)
 
-__all__ = ["AgentBase", "AgentServer", "SWMLService", "SWMLBuilder", "StateManager", "FileStateManager"]
+__all__ = [
+    "AgentBase",
+    "AgentServer", 
+    "SWMLService",
+    "SWMLBuilder",
+    "SwaigFunctionResult",
+    "SWAIGFunction",
+    "DataMap",
+    "create_simple_api_tool", 
+    "create_expression_tool",
+    "ContextBuilder",
+    "Context", 
+    "Step",
+    "create_simple_context",
+    "WebService",
+    "start_agent",
+    "run_agent",
+    "list_skills",
+    "list_skills_with_params",
+    "register_skill",
+    "add_skill_directory",
+    "BedrockAgent"
+]

signalwire_agents/agent_server.py

@@ -11,7 +11,7 @@ See LICENSE file in the project root for full license information.
 AgentServer - Class for hosting multiple SignalWire AI Agents in a single server
 """
 
-import logging
+import os
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
@@ -25,6 +25,7 @@ except ImportError:
 
 from signalwire_agents.core.agent_base import AgentBase
 from signalwire_agents.core.swml_service import SWMLService
+from signalwire_agents.core.logging_config import get_logger, get_execution_mode
 
 
 class AgentServer:
@@ -48,25 +49,20 @@ class AgentServer:
         Args:
             host: Host to bind the server to
             port: Port to bind the server to
-            log_level: Logging level (debug, info, warning, error)
+            log_level: Logging level (debug, info, warning, error, critical)
         """
         self.host = host
         self.port = port
         self.log_level = log_level.lower()
         
-        # Set up logging
-        numeric_level = getattr(logging, self.log_level.upper(), logging.INFO)
-        logging.basicConfig(
-            level=numeric_level,
-            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-        )
-        self.logger = logging.getLogger("AgentServer")
+        self.logger = get_logger("AgentServer")
         
         # Create FastAPI app
         self.app = FastAPI(
             title="SignalWire AI Agents",
             description="Hosted SignalWire AI Agents",
-            version="0.1.2"
+            version="0.1.2",
+            redirect_slashes=False
         )
         
         # Keep track of registered agents
@@ -105,7 +101,8 @@ class AgentServer:
         # Store the agent
         self.agents[route] = agent
         
-        # Get the router and register it
+        # 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)
         
@@ -302,14 +299,229 @@ class AgentServer:
         
         return self.agents.get(route)
     
-    def run(self, host: Optional[str] = None, port: Optional[int] = None) -> None:
+    def run(self, event=None, context=None, host: Optional[str] = None, port: Optional[int] = None) -> Any:
         """
-        Start the server
+        Universal run method that automatically detects environment and handles accordingly
+        
+        Detects execution mode and routes appropriately:
+        - Server mode: Starts uvicorn server with FastAPI
+        - CGI mode: Uses same routing logic but outputs CGI headers  
+        - Lambda mode: Uses same routing logic but returns Lambda response
         
         Args:
-            host: Optional host to override the default
-            port: Optional port to override the default
+            event: Serverless event object (Lambda, Cloud Functions)
+            context: Serverless context object (Lambda, Cloud Functions)  
+            host: Optional host to override the default (server mode only)
+            port: Optional port to override the default (server mode only)
+            
+        Returns:
+            Response for serverless modes, None for server mode
         """
+        from signalwire_agents.core.logging_config import get_execution_mode
+        import os
+        import json
+        
+        # Detect execution mode
+        mode = get_execution_mode()
+        
+        if mode == 'cgi':
+            return self._handle_cgi_request()
+        elif mode == 'lambda':
+            return self._handle_lambda_request(event, context)
+        else:
+            # Server mode - use existing logic
+            return self._run_server(host, port)
+    
+    def _handle_cgi_request(self) -> str:
+        """Handle CGI request using same routing logic as server"""
+        import os
+        import sys
+        import json
+        
+        # Get PATH_INFO to determine routing
+        path_info = os.getenv('PATH_INFO', '').strip('/')
+        
+        # Use same routing logic as the server
+        if not path_info:
+            # Root request - return basic info or 404
+            response = {"error": "No agent specified in path"}
+            return self._format_cgi_response(response, status="404 Not Found")
+        
+        # Find matching agent using same logic as server
+        for route, agent in self.agents.items():
+            route_clean = route.lstrip("/")
+            
+            if path_info == route_clean:
+                # Request to agent root - return SWML
+                try:
+                    swml = agent._render_swml()
+                    return self._format_cgi_response(swml, content_type="application/json")
+                except Exception as e:
+                    error_response = {"error": f"Failed to generate SWML: {str(e)}"}
+                    return self._format_cgi_response(error_response, status="500 Internal Server Error")
+                    
+            elif path_info.startswith(route_clean + "/"):
+                # Request to agent sub-path
+                relative_path = path_info[len(route_clean):].lstrip("/")
+                
+                if relative_path == "swaig":
+                    # SWAIG function call - parse stdin for POST data
+                    try:
+                        # Read POST data from stdin
+                        content_length = os.getenv('CONTENT_LENGTH')
+                        if content_length:
+                            raw_data = sys.stdin.buffer.read(int(content_length))
+                            try:
+                                post_data = json.loads(raw_data.decode('utf-8'))
+                            except:
+                                post_data = {}
+                        else:
+                            post_data = {}
+                        
+                        # Execute SWAIG function
+                        result = agent._execute_swaig_function("", post_data, None, None)
+                        return self._format_cgi_response(result, content_type="application/json")
+                        
+                    except Exception as e:
+                        error_response = {"error": f"SWAIG function failed: {str(e)}"}
+                        return self._format_cgi_response(error_response, status="500 Internal Server Error")
+                
+                elif relative_path.startswith("swaig/"):
+                    # Direct function call like /matti/swaig/function_name
+                    function_name = relative_path[6:]  # Remove "swaig/"
+                    try:
+                        # Read POST data from stdin  
+                        content_length = os.getenv('CONTENT_LENGTH')
+                        if content_length:
+                            raw_data = sys.stdin.buffer.read(int(content_length))
+                            try:
+                                post_data = json.loads(raw_data.decode('utf-8'))
+                            except:
+                                post_data = {}
+                        else:
+                            post_data = {}
+                            
+                        result = agent._execute_swaig_function(function_name, post_data, None, None)
+                        return self._format_cgi_response(result, content_type="application/json")
+                        
+                    except Exception as e:
+                        error_response = {"error": f"Function call failed: {str(e)}"}
+                        return self._format_cgi_response(error_response, status="500 Internal Server Error")
+        
+        # No matching agent found
+        error_response = {"error": "Not Found"}
+        return self._format_cgi_response(error_response, status="404 Not Found")
+    
+    def _handle_lambda_request(self, event, context) -> dict:
+        """Handle Lambda request using same routing logic as server"""
+        import json
+        
+        # Extract path from Lambda event
+        path = ""
+        if event and 'pathParameters' in event and event['pathParameters']:
+            path = event['pathParameters'].get('proxy', '')
+        elif event and 'path' in event:
+            path = event['path']
+        
+        path = path.strip('/')
+        
+        # Use same routing logic as server
+        if not path:
+            return {
+                "statusCode": 404,
+                "headers": {"Content-Type": "application/json"},
+                "body": json.dumps({"error": "No agent specified in path"})
+            }
+        
+        # Find matching agent
+        for route, agent in self.agents.items():
+            route_clean = route.lstrip("/")
+            
+            if path == route_clean:
+                # Request to agent root - return SWML
+                try:
+                    swml = agent._render_swml()
+                    return {
+                        "statusCode": 200,
+                        "headers": {"Content-Type": "application/json"},
+                        "body": json.dumps(swml) if isinstance(swml, dict) else swml
+                    }
+                except Exception as e:
+                    return {
+                        "statusCode": 500,
+                        "headers": {"Content-Type": "application/json"},
+                        "body": json.dumps({"error": f"Failed to generate SWML: {str(e)}"})
+                    }
+                    
+            elif path.startswith(route_clean + "/"):
+                # Request to agent sub-path
+                relative_path = path[len(route_clean):].lstrip("/")
+                
+                if relative_path == "swaig" or relative_path.startswith("swaig/"):
+                    # SWAIG function call
+                    try:
+                        # Parse function name and body from event
+                        function_name = relative_path[6:] if relative_path.startswith("swaig/") else ""
+                        
+                        # Get POST data from Lambda event body
+                        post_data = {}
+                        if event and 'body' in event and event['body']:
+                            try:
+                                post_data = json.loads(event['body'])
+                            except:
+                                pass
+                        
+                        result = agent._execute_swaig_function(function_name, post_data, None, None)
+                        return {
+                            "statusCode": 200,
+                            "headers": {"Content-Type": "application/json"},
+                            "body": json.dumps(result) if isinstance(result, dict) else result
+                        }
+                        
+                    except Exception as e:
+                        return {
+                            "statusCode": 500,
+                            "headers": {"Content-Type": "application/json"},
+                            "body": json.dumps({"error": f"Function call failed: {str(e)}"})
+                        }
+        
+        # No matching agent found
+        return {
+            "statusCode": 404,
+            "headers": {"Content-Type": "application/json"},
+            "body": json.dumps({"error": "Not Found"})
+        }
+    
+    def _format_cgi_response(self, data, content_type: str = "application/json", status: str = "200 OK") -> str:
+        """Format response for CGI output"""
+        import json
+        import sys
+        
+        # Format the body
+        if isinstance(data, dict):
+            body = json.dumps(data)
+        else:
+            body = str(data)
+        
+        # Build CGI response with headers
+        response_lines = [
+            f"Status: {status}",
+            f"Content-Type: {content_type}",
+            f"Content-Length: {len(body.encode('utf-8'))}",
+            "",  # Empty line separates headers from body
+            body
+        ]
+        
+        response = "\n".join(response_lines)
+        
+        # Write directly to stdout and flush to ensure immediate output
+        sys.stdout.write(response)
+        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")
             
@@ -322,32 +534,130 @@ class AgentServer:
                 "routes": list(self.agents.keys())
             }
             
-        # Print server info
+        # 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)
+
+            # 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")
+            
+        # Set host and port
         host = host or self.host
         port = port or self.port
         
-        self.logger.info(f"Starting server on {host}:{port}")
+        # Check for SSL configuration from environment variables
+        ssl_enabled_env = os.environ.get('SWML_SSL_ENABLED', '').lower()
+        ssl_enabled = ssl_enabled_env in ('true', '1', 'yes')
+        ssl_cert_path = os.environ.get('SWML_SSL_CERT_PATH')
+        ssl_key_path = os.environ.get('SWML_SSL_KEY_PATH')
+        domain = os.environ.get('SWML_DOMAIN')
+        
+        # Validate SSL configuration if enabled
+        if ssl_enabled:
+            if not ssl_cert_path or not os.path.exists(ssl_cert_path):
+                self.logger.warning(f"SSL cert not found: {ssl_cert_path}")
+                ssl_enabled = False
+            elif not ssl_key_path or not os.path.exists(ssl_key_path):
+                self.logger.warning(f"SSL key not found: {ssl_key_path}")
+                ssl_enabled = False
+        
+        # Update server info display with correct protocol
+        protocol = "https" if ssl_enabled else "http"
+        
+        # Determine display host - include port unless it's the standard port for the protocol
+        if ssl_enabled and domain:
+            # Use domain, but include port if it's not the standard HTTPS port (443)
+            display_host = f"{domain}:{port}" if port != 443 else domain
+        else:
+            # Use host:port for HTTP or when no domain is specified
+            display_host = f"{host}:{port}"
+        
+        self.logger.info(f"Starting server on {protocol}://{display_host}")
         for route, agent in self.agents.items():
             username, password = agent.get_basic_auth_credentials()
+            agent_url = agent.get_full_url(include_auth=False)
             self.logger.info(f"Agent '{agent.get_name()}' available at:")
-            self.logger.info(f"URL: http://{host}:{port}{route}")
+            self.logger.info(f"URL: {agent_url}")
             self.logger.info(f"Basic Auth: {username}:{password}")
-            
-        # Start the server
-        uvicorn.run(
-            self.app,
-            host=host,
-            port=port,
-            log_level=self.log_level
-        )
+        
+        # Start the server with or without SSL
+        if ssl_enabled and ssl_cert_path and ssl_key_path:
+            self.logger.info(f"Starting with SSL - cert: {ssl_cert_path}, key: {ssl_key_path}")
+            uvicorn.run(
+                self.app,
+                host=host,
+                port=port,
+                log_level=self.log_level,
+                ssl_certfile=ssl_cert_path,
+                ssl_keyfile=ssl_key_path
+            )
+        else:
+            uvicorn.run(
+                self.app,
+                host=host,
+                port=port,
+                log_level=self.log_level
+            )
 
-    def register_global_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]], 
+    def register_global_routing_callback(self, callback_fn: Callable[[Request, Dict[str, Any]], Optional[str]],
                                         path: str) -> None:
         """
         Register a routing callback across all agents
-        
+
         This allows you to add unified routing logic to all agents at the same path.
-        
+
         Args:
             callback_fn: The callback function to register
             path: The path to register the callback at
@@ -355,11 +665,107 @@ class AgentServer:
         # Normalize the path
         if not path.startswith("/"):
             path = f"/{path}"
-        
+
         path = path.rstrip("/")
-        
+
         # Register with all existing agents
         for agent in self.agents.values():
             agent.register_routing_callback(callback_fn, path=path)
-        
+
         self.logger.info(f"Registered global routing callback at {path} on all agents")
+
+    def serve_static_files(self, directory: str, route: str = "/") -> None:
+        """
+        Serve static files from a directory.
+
+        This method properly integrates static file serving with agent routes,
+        ensuring that agent routes take priority over static files.
+
+        Unlike using StaticFiles.mount("/", ...) directly on self.app, this method
+        uses explicit route handlers that work correctly with agent routes.
+
+        Args:
+            directory: Path to the directory containing static files
+            route: URL path prefix for static files (default: "/" for root)
+
+        Example:
+            server = AgentServer()
+            server.register(SupportAgent(), "/support")
+            server.serve_static_files("./web")  # Serves at /
+            # /support -> SupportAgent
+            # /index.html -> ./web/index.html
+            # / -> ./web/index.html
+        """
+        from pathlib import Path
+        from fastapi.responses import FileResponse
+        from fastapi import HTTPException
+
+        # Normalize directory path
+        static_dir = Path(directory).resolve()
+
+        if not static_dir.exists():
+            raise ValueError(f"Directory does not exist: {directory}")
+
+        if not static_dir.is_dir():
+            raise ValueError(f"Path is not a directory: {directory}")
+
+        # Normalize route
+        if not route.startswith("/"):
+            route = f"/{route}"
+        route = route.rstrip("/")
+
+        # Store static directory config for use by catch-all handler
+        if not hasattr(self, '_static_directories'):
+            self._static_directories = {}
+
+        self._static_directories[route] = static_dir
+
+        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.
+
+        Args:
+            file_path: The requested file path
+            route: The route prefix
+
+        Returns:
+            FileResponse if file exists, None otherwise
+        """
+        from pathlib import Path
+        from fastapi.responses import FileResponse
+
+        if not hasattr(self, '_static_directories'):
+            return None
+
+        static_dir = self._static_directories.get(route)
+        if not static_dir:
+            return None
+
+        # Default to index.html for empty path
+        if not file_path:
+            file_path = "index.html"
+
+        full_path = static_dir / file_path
+
+        # Security: prevent path traversal
+        try:
+            full_path = full_path.resolve()
+            if not str(full_path).startswith(str(static_dir)):
+                return None
+        except Exception:
+            return None
+
+        # Handle directory requests
+        if full_path.is_dir():
+            index_path = full_path / "index.html"
+            if index_path.exists():
+                full_path = index_path
+            else:
+                return None
+
+        if not full_path.exists():
+            return None
+
+        return FileResponse(full_path)