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

signalwire_agents/__init__.py

@@ -18,41 +18,120 @@ A package for building AI agents using SignalWire's AI and SWML capabilities.
 from .core.logging_config import configure_logging
 configure_logging()
 
-__version__ = "0.1.13"
+__version__ = "1.0.7"
 
 # Import core classes for easier access
 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 .core.state import StateManager, FileStateManager
 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.function_result import SwaigFunctionResult
 from signalwire_agents.core.swaig_function import SWAIGFunction
+from signalwire_agents.agents.bedrock import BedrockAgent
 
-# Import skills to trigger discovery
-import signalwire_agents.skills
+# Import WebService for static file serving
+from signalwire_agents.web import WebService
 
-# Import convenience functions from the CLI (if available)
-try:
-    from signalwire_agents.cli.helpers import start_agent, run_agent, list_skills
-except ImportError:
-    # CLI helpers not available, define minimal versions
-    def start_agent(*args, **kwargs):
+# 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):
+
+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):
+
+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",
     "SwaigFunctionResult",
     "SWAIGFunction",
     "DataMap",
@@ -62,7 +141,12 @@ __all__ = [
     "Context", 
     "Step",
     "create_simple_context",
+    "WebService",
     "start_agent",
     "run_agent",
-    "list_skills"
+    "list_skills",
+    "list_skills_with_params",
+    "register_skill",
+    "add_skill_directory",
+    "BedrockAgent"
 ]

signalwire_agents/agent_server.py

@@ -11,6 +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 os
 import re
 from typing import Dict, Any, Optional, List, Tuple, Callable
 
@@ -548,11 +549,11 @@ class AgentServer:
                     # 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)
@@ -563,7 +564,7 @@ class AgentServer:
                         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():
@@ -571,36 +572,92 @@ class AgentServer:
                             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")
             
-            # No matching agent found
-            return {"error": "Not Found"}
-            
-        # Print server info
+        # 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
@@ -608,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)

signalwire_agents/agents/bedrock.py

@@ -0,0 +1,296 @@
+"""
+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.
+"""
+
+"""
+Bedrock Agent - Amazon Bedrock voice-to-voice integration
+
+This module provides BedrockAgent, which extends AgentBase to support
+Amazon Bedrock's voice-to-voice model while maintaining compatibility
+with all SignalWire agent features like skills, POM, and SWAIG functions.
+"""
+
+import json
+from typing import Dict, List, Any, Optional, Union
+from signalwire_agents.core.agent_base import AgentBase
+from signalwire_agents.core.logging_config import get_logger
+
+logger = get_logger("bedrock_agent")
+
+
+class BedrockAgent(AgentBase):
+    """
+    Agent implementation for Amazon Bedrock voice-to-voice model
+    
+    This agent extends AgentBase to provide full compatibility with
+    SignalWire's agent ecosystem while using Amazon Bedrock as the
+    AI backend. It supports all standard agent features including:
+    - Prompt building with text and POM
+    - Skills and SWAIG functions
+    - Post-prompt functionality
+    - Dynamic configuration
+    
+    The main difference from the standard agent is that it generates
+    SWML with the "amazon_bedrock" verb instead of "ai".
+    """
+    
+    def __init__(
+        self,
+        name: str = "bedrock_agent",
+        route: str = "/bedrock",
+        system_prompt: Optional[str] = None,
+        voice_id: str = "matthew",
+        temperature: float = 0.7,
+        top_p: float = 0.9,
+        max_tokens: int = 1024,
+        **kwargs
+    ):
+        """
+        Initialize BedrockAgent
+        
+        Args:
+            name: Agent name
+            route: HTTP route for the agent
+            system_prompt: Initial system prompt (can be overridden with set_prompt)
+            voice_id: Bedrock voice ID (default: matthew)
+            temperature: Generation temperature (0-1)
+            top_p: Nucleus sampling parameter (0-1)
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional arguments passed to AgentBase
+        """
+        # Store Bedrock-specific parameters first
+        self._voice_id = voice_id
+        self._temperature = temperature
+        self._top_p = top_p
+        self._max_tokens = max_tokens
+        
+        # Initialize base class
+        super().__init__(name=name, route=route, **kwargs)
+        
+        # Set initial prompt if provided (after super init)
+        if system_prompt:
+            self.set_prompt_text(system_prompt)
+        
+        logger.info(f"BedrockAgent initialized: {name} on route {route}")
+    
+    def _render_swml(self, call_id: str = None, modifications: Optional[dict] = None) -> str:
+        """
+        Render SWML document with amazon_bedrock verb
+        
+        This method overrides the base implementation to generate
+        SWML with the amazon_bedrock verb structure that matches
+        the ai verb structure for consistency.
+        
+        Args:
+            call_id: Optional call ID for session-specific tokens
+            modifications: Optional dict of modifications to apply
+            
+        Returns:
+            SWML document as JSON string with amazon_bedrock verb
+        """
+        # Call parent to build the base SWML with ai verb
+        base_swml_json = super()._render_swml(call_id, modifications)
+        
+        # Parse the JSON to modify it
+        swml = json.loads(base_swml_json)
+        
+        # Find and transform the ai verb to amazon_bedrock
+        sections = swml.get("sections", {})
+        main_section = sections.get("main", [])
+        
+        # Look for ai verb and transform it
+        for i, verb in enumerate(main_section):
+            if "ai" in verb:
+                ai_config = verb["ai"]
+                
+                # Build amazon_bedrock verb with same structure
+                bedrock_verb = {
+                    "amazon_bedrock": {
+                        # Add voice configuration and inference params inside prompt
+                        # Note: In Bedrock, voice and inference params are part of prompt config
+                        "prompt": self._add_voice_to_prompt(ai_config.get("prompt", {})),
+                        
+                        # Copy SWAIG if present
+                        "SWAIG": ai_config.get("SWAIG", {}),
+                        
+                        # Include params only if they were explicitly set via set_params()
+                        # The C++ code ignores params for now (marked for future extensibility)
+                        "params": ai_config.get("params", {}),
+                        
+                        # Copy global_data if present
+                        "global_data": ai_config.get("global_data", {}),
+                        
+                        # Copy post_prompt if present
+                        "post_prompt": ai_config.get("post_prompt"),
+                        
+                        # Copy post_prompt_url if present
+                        "post_prompt_url": ai_config.get("post_prompt_url")
+                    }
+                }
+                
+                # Remove None values
+                bedrock_config = bedrock_verb["amazon_bedrock"]
+                bedrock_verb["amazon_bedrock"] = {
+                    k: v for k, v in bedrock_config.items() 
+                    if v is not None
+                }
+                
+                # Replace ai verb with amazon_bedrock verb
+                main_section[i] = bedrock_verb
+                break
+        
+        # Convert back to JSON string
+        return json.dumps(swml)
+    
+    def _add_voice_to_prompt(self, prompt_config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Add voice configuration to the prompt object
+        
+        In Bedrock, voice configuration is part of the prompt object,
+        not a separate field like in OpenAI.
+        
+        Args:
+            prompt_config: Current prompt configuration
+            
+        Returns:
+            Updated prompt configuration with voice
+        """
+        # Create a clean copy, filtering out text-model-specific parameters
+        # that don't apply to Bedrock's voice-to-voice model
+        filtered_config = {}
+        
+        # Copy over only the relevant fields
+        for key, value in prompt_config.items():
+            # Skip text-model-specific parameters
+            if key in ['barge_confidence', 'presence_penalty', 'frequency_penalty']:
+                continue
+            filtered_config[key] = value
+        
+        # Add voice_id to the prompt configuration
+        filtered_config["voice_id"] = self._voice_id
+        
+        # Add/override inference parameters (where C code expects them)
+        filtered_config["temperature"] = self._temperature
+        filtered_config["top_p"] = self._top_p
+        
+        return filtered_config
+    
+    def _build_bedrock_params(self, base_params: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Build Bedrock-specific parameters
+        
+        Merges base parameters with Bedrock-specific inference settings.
+        
+        Args:
+            base_params: Base parameters from AgentBase
+            
+        Returns:
+            Combined parameters for Bedrock
+        """
+        # Start with base params
+        params = base_params.copy()
+        
+        # Add Bedrock inference parameters
+        params.update({
+            "temperature": self._temperature,
+            "top_p": self._top_p,
+            "max_tokens": self._max_tokens
+        })
+        
+        return params
+    
+    def set_voice(self, voice_id: str) -> None:
+        """
+        Set the Bedrock voice ID
+        
+        Args:
+            voice_id: Bedrock voice identifier (e.g., 'matthew', 'joanna')
+        """
+        self._voice_id = voice_id
+        logger.debug(f"Voice set to: {voice_id}")
+    
+    def set_inference_params(
+        self,
+        temperature: Optional[float] = None,
+        top_p: Optional[float] = None,
+        max_tokens: Optional[int] = None
+    ) -> None:
+        """
+        Update Bedrock inference parameters
+        
+        Args:
+            temperature: Generation temperature (0-1)
+            top_p: Nucleus sampling parameter (0-1)
+            max_tokens: Maximum tokens to generate
+        """
+        if temperature is not None:
+            self._temperature = temperature
+        if top_p is not None:
+            self._top_p = top_p
+        if max_tokens is not None:
+            self._max_tokens = max_tokens
+        
+        logger.debug(f"Inference params updated: temp={self._temperature}, "
+                    f"top_p={self._top_p}, max_tokens={self._max_tokens}")
+    
+    # Methods that may not be relevant to Bedrock
+    # These are overridden to provide appropriate behavior or warnings
+    
+    def set_llm_model(self, model: str) -> None:
+        """
+        Set LLM model - not applicable for Bedrock
+        
+        Bedrock uses a fixed voice-to-voice model, so this method
+        logs a warning and does nothing.
+        
+        Args:
+            model: Model name (ignored)
+        """
+        logger.warning(f"set_llm_model('{model}') called but Bedrock uses a fixed voice-to-voice model")
+    
+    def set_llm_temperature(self, temperature: float) -> None:
+        """
+        Set LLM temperature - redirects to set_inference_params
+        
+        Args:
+            temperature: Temperature value
+        """
+        self.set_inference_params(temperature=temperature)
+    
+    def set_post_prompt_llm_params(self, **params) -> None:
+        """
+        Set post-prompt LLM parameters - not applicable for Bedrock
+        
+        Bedrock uses OpenAI for post-prompt summarization, but those
+        parameters are configured in the C code.
+        
+        Args:
+            **params: Ignored parameters
+        """
+        logger.warning("set_post_prompt_llm_params() called but Bedrock post-prompt uses OpenAI configured in C code")
+    
+    def set_prompt_llm_params(self, **params) -> None:
+        """
+        Set prompt LLM parameters - use set_inference_params instead
+        
+        For Bedrock, use set_inference_params() to configure temperature,
+        top_p, and max_tokens.
+        
+        Args:
+            **params: Parameters (ignored, use set_inference_params)
+        """
+        logger.warning("set_prompt_llm_params() called - use set_inference_params() for Bedrock")
+    
+    # Note: We don't override prompt methods like set_prompt_text, set_prompt_pom
+    # because those work fine - they just build the prompt structure that we
+    # transform in _render_swml()
+    
+    def __repr__(self) -> str:
+        """String representation of the agent"""
+        return (f"BedrockAgent(name='{self.name}', route='{self.route}', "
+                f"voice='{self._voice_id}')")