signalwire-agents 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

signalwire_agents/prefabs/faq_bot.py

@@ -51,7 +51,6 @@ class FAQBotAgent(AgentBase):
         persona: Optional[str] = None,
         name: str = "faq_bot",
         route: str = "/faq",
-        enable_state_tracking: bool = True,  # Enable state tracking by default
         **kwargs
     ):
         """
@@ -66,7 +65,6 @@ class FAQBotAgent(AgentBase):
             persona: Optional custom personality description
             name: Agent name for the route
             route: HTTP route for this agent
-            enable_state_tracking: Whether to enable state tracking (default: True)
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
@@ -74,7 +72,6 @@ class FAQBotAgent(AgentBase):
             name=name,
             route=route,
             use_pom=True,
-            enable_state_tracking=enable_state_tracking,  # Pass state tracking parameter to base
             **kwargs
         )
         

signalwire_agents/prefabs/info_gatherer.py

@@ -45,7 +45,6 @@ class InfoGathererAgent(AgentBase):
         questions: Optional[List[Dict[str, str]]] = None,
         name: str = "info_gatherer", 
         route: str = "/info_gatherer",
-        enable_state_tracking: bool = True,  # Enable state tracking by default for InfoGatherer
         **kwargs
     ):
         """
@@ -59,7 +58,6 @@ class InfoGathererAgent(AgentBase):
                 - confirm: (Optional) If set to True, the agent will confirm the answer before submitting
             name: Agent name for the route
             route: HTTP route for this agent
-            enable_state_tracking: Whether to enable state tracking (default: True)
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
@@ -67,7 +65,6 @@ class InfoGathererAgent(AgentBase):
             name=name,
             route=route,
             use_pom=True,
-            enable_state_tracking=enable_state_tracking,  # Pass state tracking parameter to base
             **kwargs
         )
         

signalwire_agents/prefabs/receptionist.py

@@ -41,7 +41,6 @@ class ReceptionistAgent(AgentBase):
         route: str = "/receptionist",
         greeting: str = "Thank you for calling. How can I help you today?",
         voice: str = "rime.spore",
-        enable_state_tracking: bool = True,  # Enable state tracking by default
         **kwargs
     ):
         """
@@ -56,7 +55,6 @@ class ReceptionistAgent(AgentBase):
             route: HTTP route for this agent
             greeting: Initial greeting message
             voice: Voice ID to use
-            enable_state_tracking: Whether to enable state tracking (default: True)
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
@@ -64,7 +62,6 @@ class ReceptionistAgent(AgentBase):
             name=name,
             route=route,
             use_pom=True,
-            enable_state_tracking=enable_state_tracking,  # Pass state tracking parameter to base
             **kwargs
         )
         

signalwire_agents/prefabs/survey.py

@@ -62,7 +62,6 @@ class SurveyAgent(AgentBase):
         max_retries: int = 2,
         name: str = "survey",
         route: str = "/survey",
-        enable_state_tracking: bool = True,  # Enable state tracking by default
         **kwargs
     ):
         """
@@ -83,7 +82,6 @@ class SurveyAgent(AgentBase):
             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")
-            enable_state_tracking: Whether to enable state tracking (default: True)
             **kwargs: Additional arguments for AgentBase
         """
         # Initialize the base agent
@@ -91,7 +89,6 @@ class SurveyAgent(AgentBase):
             name=name,
             route=route,
             use_pom=True,
-            enable_state_tracking=enable_state_tracking,  # Pass state tracking parameter to base
             **kwargs
         )
         

signalwire_agents/search/search_service.py

@@ -8,15 +8,23 @@ See LICENSE file in the project root for full license information.
 """
 
 import logging
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, Tuple
 
 try:
-    from fastapi import FastAPI, HTTPException
+    from fastapi import FastAPI, HTTPException, Request, Response, Depends
+    from fastapi.middleware.cors import CORSMiddleware
+    from fastapi.security import HTTPBasic, HTTPBasicCredentials
     from pydantic import BaseModel
 except ImportError:
     FastAPI = None
     HTTPException = None
     BaseModel = None
+    Request = None
+    Response = None
+    Depends = None
+    CORSMiddleware = None
+    HTTPBasic = None
+    HTTPBasicCredentials = None
 
 try:
     from sentence_transformers import SentenceTransformer
@@ -25,8 +33,11 @@ except ImportError:
 
 from .query_processor import preprocess_query
 from .search_engine import SearchEngine
+from signalwire_agents.core.security_config import SecurityConfig
+from signalwire_agents.core.config_loader import ConfigLoader
+from signalwire_agents.core.logging_config import get_logger
 
-logger = logging.getLogger(__name__)
+logger = get_logger("search_service")
 
 # Pydantic models for API
 if BaseModel:
@@ -73,14 +84,30 @@ else:
 class SearchService:
     """Local search service with HTTP API"""
     
-    def __init__(self, port: int = 8001, indexes: Dict[str, str] = None):
+    def __init__(self, port: int = 8001, indexes: Dict[str, str] = None, 
+                 basic_auth: Optional[Tuple[str, str]] = None,
+                 config_file: Optional[str] = None):
+        # Load configuration first
+        self._load_config(config_file)
+        
+        # Override with constructor params if provided
         self.port = port
-        self.indexes = indexes or {}
+        if indexes is not None:
+            self.indexes = indexes
+        
         self.search_engines = {}
         self.model = None
         
+        # Load security configuration with optional config file
+        self.security = SecurityConfig(config_file=config_file, service_name="search")
+        self.security.log_config("SearchService")
+        
+        # Set up authentication
+        self._basic_auth = basic_auth or self.security.get_basic_auth()
+        
         if FastAPI:
             self.app = FastAPI(title="SignalWire Local Search Service")
+            self._setup_security()
             self._setup_routes()
         else:
             self.app = None
@@ -88,22 +115,131 @@ class SearchService:
         
         self._load_resources()
     
+    def _load_config(self, config_file: Optional[str]):
+        """Load configuration from file if available"""
+        # Initialize defaults
+        self.indexes = {}
+        
+        # Find config file
+        if not config_file:
+            config_file = ConfigLoader.find_config_file("search")
+        
+        if not config_file:
+            return
+            
+        # Load config
+        config_loader = ConfigLoader([config_file])
+        if not config_loader.has_config():
+            return
+            
+        logger.info("loading_config_from_file", file=config_file)
+        
+        # Get service section
+        service_config = config_loader.get_section('service')
+        if service_config:
+            if 'port' in service_config:
+                self.port = int(service_config['port'])
+            
+            if 'indexes' in service_config and isinstance(service_config['indexes'], dict):
+                self.indexes = service_config['indexes']
+    
+    def _setup_security(self):
+        """Setup security middleware and authentication"""
+        if not self.app:
+            return
+            
+        # Add CORS middleware if FastAPI has it
+        if CORSMiddleware:
+            self.app.add_middleware(
+                CORSMiddleware,
+                **self.security.get_cors_config()
+            )
+        
+        # Add security headers middleware
+        @self.app.middleware("http")
+        async def add_security_headers(request: Request, call_next):
+            response = await call_next(request)
+            
+            # Add security headers
+            is_https = request.url.scheme == "https"
+            headers = self.security.get_security_headers(is_https)
+            for header, value in headers.items():
+                response.headers[header] = value
+            
+            return response
+        
+        # Add host validation middleware
+        @self.app.middleware("http")
+        async def validate_host(request: Request, call_next):
+            host = request.headers.get("host", "").split(":")[0]
+            if host and not self.security.should_allow_host(host):
+                return Response(content="Invalid host", status_code=400)
+            
+            return await call_next(request)
+    
+    def _get_current_username(self, credentials: HTTPBasicCredentials = None) -> str:
+        """Validate basic auth credentials"""
+        if not credentials:
+            return None
+            
+        correct_username, correct_password = self._basic_auth
+        
+        # Compare credentials
+        import secrets
+        username_correct = secrets.compare_digest(credentials.username, correct_username)
+        password_correct = secrets.compare_digest(credentials.password, correct_password)
+        
+        if not (username_correct and password_correct):
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid authentication credentials",
+                headers={"WWW-Authenticate": "Basic"},
+            )
+        
+        return credentials.username
+    
     def _setup_routes(self):
         """Setup FastAPI routes"""
         if not self.app:
             return
+        
+        # Create security dependency if HTTPBasic is available
+        security = HTTPBasic() if HTTPBasic else None
+        
+        # Create dependency for authenticated routes
+        def get_authenticated():
+            if security:
+                return security
+            return None
             
         @self.app.post("/search", response_model=SearchResponse)
-        async def search(request: SearchRequest):
+        async def search(
+            request: SearchRequest,
+            credentials: HTTPBasicCredentials = None if not security else Depends(security)
+        ):
+            if security:
+                self._get_current_username(credentials)
             return await self._handle_search(request)
         
         @self.app.get("/health")
         async def health():
-            return {"status": "healthy", "indexes": list(self.indexes.keys())}
+            return {
+                "status": "healthy", 
+                "indexes": list(self.indexes.keys()),
+                "ssl_enabled": self.security.ssl_enabled,
+                "auth_required": bool(security)
+            }
         
         @self.app.post("/reload_index")
-        async def reload_index(index_name: str, index_path: str):
+        async def reload_index(
+            index_name: str, 
+            index_path: str,
+            credentials: HTTPBasicCredentials = None if not security else Depends(security)
+        ):
             """Reload or add new index"""
+            if security:
+                self._get_current_username(credentials)
+                
             self.indexes[index_name] = index_path
             self.search_engines[index_name] = SearchEngine(index_path, self.model)
             return {"status": "reloaded", "index": index_name}
@@ -235,14 +371,67 @@ class SearchService:
             'query_analysis': response.query_analysis
         }
     
-    def start(self):
-        """Start the service"""
+    def start(self, host: str = "0.0.0.0", port: Optional[int] = None,
+              ssl_cert: Optional[str] = None, ssl_key: Optional[str] = None):
+        """
+        Start the service with optional HTTPS support.
+        
+        Args:
+            host: Host to bind to (default: "0.0.0.0")
+            port: Port to bind to (default: self.port)
+            ssl_cert: Path to SSL certificate file (overrides environment)
+            ssl_key: Path to SSL key file (overrides environment)
+        """
         if not self.app:
             raise RuntimeError("FastAPI not available. Cannot start HTTP service.")
         
+        port = port or self.port
+        
+        # Get SSL configuration
+        ssl_kwargs = {}
+        if ssl_cert and ssl_key:
+            # Use provided SSL files
+            ssl_kwargs = {
+                'ssl_certfile': ssl_cert,
+                'ssl_keyfile': ssl_key
+            }
+        else:
+            # Use security config SSL settings
+            ssl_kwargs = self.security.get_ssl_context_kwargs()
+        
+        # Build startup URL
+        scheme = "https" if ssl_kwargs else "http"
+        startup_url = f"{scheme}://{host}:{port}"
+        
+        # Get auth credentials
+        username, password = self._basic_auth
+        
+        # Log startup information
+        logger.info(
+            "starting_search_service",
+            url=startup_url,
+            ssl_enabled=bool(ssl_kwargs),
+            indexes=list(self.indexes.keys()),
+            username=username
+        )
+        
+        # Print user-friendly startup message
+        print(f"\nSignalWire Search Service starting...")
+        print(f"URL: {startup_url}")
+        print(f"Indexes: {', '.join(self.indexes.keys()) if self.indexes else 'None'}")
+        print(f"Basic Auth: {username}:{password}")
+        if ssl_kwargs:
+            print(f"SSL: Enabled")
+        print("")
+        
         try:
             import uvicorn
-            uvicorn.run(self.app, host="0.0.0.0", port=self.port)
+            uvicorn.run(
+                self.app, 
+                host=host, 
+                port=port,
+                **ssl_kwargs
+            )
         except ImportError:
             raise RuntimeError("uvicorn not available. Cannot start HTTP service.")
     

signalwire_agents/skills/mcp_gateway/README.md

@@ -0,0 +1,230 @@
+# MCP Gateway Skill
+
+Bridge MCP (Model Context Protocol) servers with SignalWire SWAIG functions, allowing agents to seamlessly interact with MCP-based tools.
+
+## Description
+
+The MCP Gateway skill connects SignalWire agents to MCP servers through a centralized gateway service. It dynamically discovers and registers MCP tools as SWAIG functions, maintaining session state throughout each call.
+
+## Features
+
+- Dynamic tool discovery from MCP servers
+- Session management tied to SignalWire call IDs
+- Automatic cleanup on call hangup
+- Support for multiple MCP services
+- Selective tool loading
+- HTTPS support with SSL verification
+- Retry logic for resilient connections
+
+## Requirements
+
+- Running MCP Gateway service
+- Network access to gateway
+- Gateway credentials (username/password)
+
+## Configuration
+
+### Required Parameters
+
+Either Basic Auth credentials OR Bearer token:
+- `gateway_url`: URL of the MCP gateway service (default: "http://localhost:8100")
+- `auth_user` + `auth_password`: Basic auth credentials
+- OR `auth_token`: Bearer token for authentication
+
+### Optional Parameters
+
+- `services`: Array of services to load (default: all available)
+  - `name`: Service name
+  - `tools`: Array of tool names or "*" for all (default: all)
+- `session_timeout`: Session timeout in seconds (default: 300)
+- `tool_prefix`: Prefix for SWAIG function names (default: "mcp_")
+- `retry_attempts`: Number of retry attempts (default: 3)
+- `request_timeout`: HTTP request timeout in seconds (default: 30)
+- `verify_ssl`: Verify SSL certificates (default: true)
+
+## Usage
+
+### Basic Usage (All Services)
+
+```python
+from signalwire_agents import AgentBase
+
+class MyAgent(AgentBase):
+    def __init__(self):
+        super().__init__(name="My Agent")
+        
+        # Load all available MCP services
+        self.add_skill("mcp_gateway", {
+            "gateway_url": "http://localhost:8080",
+            "auth_user": "admin",
+            "auth_password": "changeme"
+        })
+
+agent = MyAgent()
+agent.run()
+```
+
+### Selective Service Loading
+
+```python
+# Load specific services with specific tools
+self.add_skill("mcp_gateway", {
+    "gateway_url": "https://gateway.example.com",
+    "auth_user": "admin",
+    "auth_password": "secret",
+    "services": [
+        {
+            "name": "todo",
+            "tools": ["add_todo", "list_todos"]  # Only these tools
+        },
+        {
+            "name": "calculator",
+            "tools": "*"  # All calculator tools
+        }
+    ],
+    "session_timeout": 600,
+    "tool_prefix": "ext_"
+})
+```
+
+### HTTPS with Self-Signed Certificate
+
+```python
+self.add_skill("mcp_gateway", {
+    "gateway_url": "https://localhost:8443",
+    "auth_user": "admin",
+    "auth_password": "secret",
+    "verify_ssl": False  # For self-signed certificates
+})
+```
+
+### Bearer Token Authentication
+
+```python
+self.add_skill("mcp_gateway", {
+    "gateway_url": "https://gateway.example.com",
+    "auth_token": "your-bearer-token-here",
+    "services": [{
+        "name": "todo"
+    }]
+})
+```
+
+## Generated Functions
+
+The skill dynamically generates SWAIG functions based on discovered MCP tools. Function names follow the pattern:
+
+`{tool_prefix}{service_name}_{tool_name}`
+
+For example, with default settings:
+- `mcp_todo_add_todo` - Add a todo item
+- `mcp_todo_list_todos` - List todo items
+- `mcp_calculator_add` - Calculator addition
+
+## Example Conversations
+
+### Using Todo Service
+
+```
+User: "Add a task to buy milk"
+Assistant: "I'll add that to your todo list."
+[Calls mcp_todo_add_todo with text="buy milk"]
+Assistant: "I've added 'buy milk' to your todo list."
+
+User: "What's on my todo list?"
+Assistant: "Let me check your todos."
+[Calls mcp_todo_list_todos]
+Assistant: "Here are your current todos:
+○ #1 [medium] buy milk"
+```
+
+### Multiple Services
+
+```
+User: "Add 'finish report' to my todos and calculate 15% of 200"
+Assistant: "I'll add that todo and do the calculation for you."
+[Calls mcp_todo_add_todo with text="finish report"]
+[Calls mcp_calculator_percent with value=200, percent=15]
+Assistant: "I've added 'finish report' to your todos. 15% of 200 is 30."
+```
+
+## Session Management
+
+- Each SignalWire call gets its own MCP session
+- Sessions persist across multiple tool calls
+- Automatic cleanup on call hangup
+- Configurable timeout for inactive sessions
+
+### Custom Session ID
+
+You can override the session ID by setting `mcp_call_id` in global_data:
+
+```python
+# In your agent code
+self.set_global_data({
+    "mcp_call_id": "custom-session-123"
+})
+
+# Or in a SWAIG function
+result = SwaigFunctionResult("Session changed")
+result.add_action("set_global_data", {"mcp_call_id": "new-session-456"})
+```
+
+This is useful for:
+- Managing multiple MCP sessions within a single call
+- Sharing MCP sessions across different calls
+- Custom session management strategies
+
+## Troubleshooting
+
+### Gateway Connection Failed
+
+Check:
+1. Gateway service is running
+2. Correct URL and credentials
+3. Network connectivity
+4. Firewall rules
+
+### SSL Certificate Errors
+
+For self-signed certificates:
+```python
+"verify_ssl": False
+```
+
+For custom CA certificates, ensure they're in the system trust store.
+
+### Tool Not Found
+
+Verify:
+1. Service name is correct
+2. Tool name matches exactly
+3. Tool is included in service configuration
+4. MCP server is returning tools correctly
+
+### Session Timeouts
+
+Increase timeout if needed:
+```python
+"session_timeout": 600  # 10 minutes
+```
+
+## Gateway Setup
+
+To run the MCP Gateway service:
+
+```bash
+cd mcp_gateway
+python3 gateway_service.py
+
+# Or with custom config
+python3 gateway_service.py -c myconfig.json
+```
+
+## Security Considerations
+
+1. Always use HTTPS in production
+2. Use strong authentication credentials
+3. Limit service access to required tools only
+4. Monitor gateway logs for suspicious activity
+5. Set appropriate session timeouts

signalwire_agents/skills/mcp_gateway/__init__.py

@@ -0,0 +1 @@
+"""MCP Gateway Skill for SignalWire Agents"""