signalwire-agents 0.1.43__py3-none-any.whl → 0.1.45__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__ = "0.1.43"
+__version__ = "0.1.45"
 
 # Import core classes for easier access
 from .core.agent_base import AgentBase
@@ -31,6 +31,9 @@ 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():
@@ -138,6 +141,7 @@ __all__ = [
     "Context", 
     "Step",
     "create_simple_context",
+    "WebService",
     "start_agent",
     "run_agent",
     "list_skills",

signalwire_agents/core/agent_base.py

@@ -562,6 +562,7 @@ class AgentBase(
             SWML document as a string
         """
         self.log.debug("_render_swml_called", 
+                      call_id=call_id,
                       has_modifications=bool(modifications),
                       use_ephemeral=bool(modifications and modifications.get("__use_ephemeral_agent")),
                       has_dynamic_callback=bool(self._dynamic_config_callback))
@@ -618,6 +619,9 @@ class AgentBase(
         # Generate a call ID if needed
         if call_id is None:
             call_id = agent_to_use._session_manager.create_session()
+            self.log.debug("generated_call_id", call_id=call_id)
+        else:
+            self.log.debug("using_provided_call_id", call_id=call_id)
             
         # Start with any SWAIG query params that were set
         query_params = agent_to_use._swaig_query_params.copy() if agent_to_use._swaig_query_params else {}
@@ -679,6 +683,7 @@ class AgentBase(
                 token = None
                 if func.secure and call_id:
                     token = agent_to_use._create_tool_token(tool_name=name, call_id=call_id)
+                    self.log.debug("created_token_for_function", function=name, call_id=call_id, token_prefix=token[:20] if token else None)
                     
                 # Prepare function entry
                 function_entry = {

signalwire_agents/core/mixins/prompt_mixin.py

@@ -7,7 +7,13 @@ Licensed under the MIT License.
 See LICENSE file in the project root for full license information.
 """
 
-from typing import Optional, Union, List, Dict, Any
+from typing import Optional, Union, List, Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from signalwire_agents.core.agent_base import AgentBase
+    from signalwire_agents.core.contexts import ContextBuilder
+else:
+    from signalwire_agents.core.contexts import ContextBuilder
 
 
 class PromptMixin:
@@ -112,7 +118,7 @@ class PromptMixin:
                                             bullets=sub_bullets if sub_bullets else None
                                         )
     
-    def define_contexts(self, contexts=None) -> Optional['ContextBuilder']:
+    def define_contexts(self, contexts=None) -> Union['AgentBase', 'ContextBuilder']:
         """
         Define contexts and steps for this agent (alternative to POM/prompt)
         
@@ -132,15 +138,22 @@ class PromptMixin:
             return self
         else:
             # Legacy behavior - return ContextBuilder
-            # Import here to avoid circular imports
-            from signalwire_agents.core.contexts import ContextBuilder
-            
             if self._contexts_builder is None:
                 self._contexts_builder = ContextBuilder(self)
                 self._contexts_defined = True
             
             return self._contexts_builder
     
+    @property
+    def contexts(self) -> 'ContextBuilder':
+        """
+        Get the ContextBuilder for this agent
+        
+        Returns:
+            ContextBuilder instance for defining contexts
+        """
+        return self.define_contexts()
+    
     def _validate_prompt_mode_exclusivity(self):
         """
         Validate that POM sections and raw text are not mixed in the main prompt

signalwire_agents/core/mixins/web_mixin.py

@@ -494,6 +494,10 @@ class WebMixin:
                     
                 # Get call_id from body if present
                 call_id = body.get("call_id")
+                if not call_id and "call" in body:
+                    # Sometimes it might be nested under 'call'
+                    call_id = body.get("call", {}).get("call_id")
+                req_log.debug("extracted_call_id_from_body", call_id=call_id, body_keys=list(body.keys()))
             else:
                 # Get call_id from query params for GET
                 call_id = request.query_params.get("call_id")

signalwire_agents/web/__init__.py

@@ -0,0 +1,17 @@
+"""
+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.
+"""
+
+"""SignalWire Agents Web Service Module
+
+This module provides static file serving capabilities for the SignalWire Agents SDK.
+"""
+
+from .web_service import WebService
+
+__all__ = ['WebService']

signalwire_agents/web/web_service.py

@@ -0,0 +1,559 @@
+"""
+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.
+"""
+
+import os
+import mimetypes
+from pathlib import Path
+from typing import Dict, Optional, Tuple, Any
+import logging
+
+try:
+    from fastapi import FastAPI, HTTPException, Request, Response, Depends
+    from fastapi.middleware.cors import CORSMiddleware
+    from fastapi.security import HTTPBasic, HTTPBasicCredentials
+    from fastapi.staticfiles import StaticFiles
+    from fastapi.responses import FileResponse, HTMLResponse
+except ImportError:
+    FastAPI = None
+    HTTPException = None
+    Request = None
+    Response = None
+    Depends = None
+    CORSMiddleware = None
+    HTTPBasic = None
+    HTTPBasicCredentials = None
+    StaticFiles = None
+    FileResponse = None
+    HTMLResponse = None
+
+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 = get_logger("web_service")
+
+class WebService:
+    """Static file serving service with HTTP API"""
+    
+    def __init__(self, 
+                 port: int = 8002,
+                 directories: Dict[str, str] = None,
+                 basic_auth: Optional[Tuple[str, str]] = None,
+                 config_file: Optional[str] = None,
+                 enable_directory_browsing: bool = False,
+                 allowed_extensions: Optional[list] = None,
+                 blocked_extensions: Optional[list] = None,
+                 max_file_size: int = 100 * 1024 * 1024,  # 100MB default
+                 enable_cors: bool = True):
+        """
+        Initialize WebService
+        
+        Args:
+            port: Port to bind to (default: 8002)
+            directories: Dict mapping URL paths to local directories
+            basic_auth: Optional tuple of (username, password)
+            config_file: Optional configuration file path
+            enable_directory_browsing: Allow directory listing
+            allowed_extensions: List of allowed file extensions (e.g., ['.html', '.css'])
+            blocked_extensions: List of blocked extensions (e.g., ['.env', '.git'])
+            max_file_size: Maximum file size in bytes to serve
+            enable_cors: Enable CORS support
+        """
+        # Load configuration first
+        self._load_config(config_file)
+        
+        # Override with constructor params if provided
+        self.port = port
+        self.enable_directory_browsing = enable_directory_browsing
+        self.max_file_size = max_file_size
+        self.enable_cors = enable_cors
+        
+        if directories is not None:
+            self.directories = directories
+        
+        # Set up file extension filters
+        self.allowed_extensions = allowed_extensions
+        self.blocked_extensions = blocked_extensions or [
+            '.env', '.git', '.gitignore', '.key', '.pem', '.crt',
+            '.pyc', '__pycache__', '.DS_Store', '.swp'
+        ]
+        
+        # Initialize mimetypes
+        mimetypes.init()
+        # Add custom MIME types if needed
+        mimetypes.add_type('application/javascript', '.js')
+        mimetypes.add_type('text/css', '.css')
+        mimetypes.add_type('application/json', '.json')
+        
+        # Load security configuration
+        self.security = SecurityConfig(config_file=config_file, service_name="web")
+        self.security.log_config("WebService")
+        
+        # Set up authentication
+        self._basic_auth = basic_auth or self.security.get_basic_auth()
+        
+        if FastAPI:
+            self.app = FastAPI(
+                title="SignalWire Web Service",
+                description="Static file serving for SignalWire Agents"
+            )
+            self._setup_security()
+            self._setup_routes()
+            self._mount_directories()
+        else:
+            self.app = None
+            logger.warning("FastAPI not available. HTTP service will not be available.")
+    
+    def _load_config(self, config_file: Optional[str]):
+        """Load configuration from file if available"""
+        # Initialize defaults
+        self.directories = {}
+        self.port = 8002
+        
+        # Find config file
+        if not config_file:
+            config_file = ConfigLoader.find_config_file("web")
+        
+        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 'directories' in service_config and isinstance(service_config['directories'], dict):
+                self.directories = service_config['directories']
+            
+            if 'enable_directory_browsing' in service_config:
+                self.enable_directory_browsing = bool(service_config['enable_directory_browsing'])
+            
+            if 'max_file_size' in service_config:
+                self.max_file_size = int(service_config['max_file_size'])
+            
+            if 'allowed_extensions' in service_config:
+                self.allowed_extensions = service_config['allowed_extensions']
+            
+            if 'blocked_extensions' in service_config:
+                self.blocked_extensions = service_config['blocked_extensions']
+    
+    def _setup_security(self):
+        """Setup security middleware and authentication"""
+        if not self.app:
+            return
+            
+        # Add CORS middleware if enabled
+        if self.enable_cors and 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
+            
+            # Add cache headers for static files
+            if request.url.path.startswith(tuple(self.directories.keys())):
+                # Cache static files for 1 hour
+                response.headers["Cache-Control"] = "public, max-age=3600"
+            
+            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 _is_file_allowed(self, file_path: Path) -> bool:
+        """Check if file is allowed to be served"""
+        # Check file size
+        if file_path.stat().st_size > self.max_file_size:
+            return False
+        
+        # Check extension and name
+        ext = file_path.suffix.lower()
+        name = file_path.name
+        
+        # Check blocked extensions and names
+        for blocked in self.blocked_extensions:
+            if blocked.startswith('.'):
+                # Check both as extension and as full name (for files like .env, .gitignore)
+                if ext == blocked or name == blocked:
+                    return False
+            else:
+                if name == blocked or blocked in str(file_path):
+                    return False
+        
+        # If allowed_extensions is set, only allow those
+        if self.allowed_extensions:
+            return ext in self.allowed_extensions
+        
+        return True
+    
+    def _generate_directory_listing(self, directory: Path, url_path: str) -> str:
+        """Generate HTML directory listing"""
+        items = []
+        
+        # Add parent directory link if not at root
+        if url_path != '/':
+            items.append('<li><a href="../">../</a></li>')
+        
+        # List directories first
+        for item in sorted(directory.iterdir()):
+            if item.name.startswith('.'):
+                continue  # Skip hidden files
+                
+            if item.is_dir():
+                items.append(f'<li>📁 <a href="{item.name}/">{item.name}/</a></li>')
+        
+        # Then list files
+        for item in sorted(directory.iterdir()):
+            if item.name.startswith('.'):
+                continue
+                
+            if item.is_file() and self._is_file_allowed(item):
+                size = item.stat().st_size
+                if size < 1024:
+                    size_str = f"{size} B"
+                elif size < 1024 * 1024:
+                    size_str = f"{size / 1024:.1f} KB"
+                else:
+                    size_str = f"{size / (1024 * 1024):.1f} MB"
+                
+                items.append(f'<li>📄 <a href="{item.name}">{item.name}</a> ({size_str})</li>')
+        
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+        <head>
+            <title>Directory listing for {url_path}</title>
+            <style>
+                body {{ font-family: sans-serif; margin: 40px; }}
+                h1 {{ color: #333; }}
+                ul {{ list-style: none; padding: 0; }}
+                li {{ padding: 5px 0; }}
+                a {{ text-decoration: none; color: #0066cc; }}
+                a:hover {{ text-decoration: underline; }}
+            </style>
+        </head>
+        <body>
+            <h1>Directory listing for {url_path}</h1>
+            <ul>
+                {''.join(items)}
+            </ul>
+        </body>
+        </html>
+        """
+        return html
+    
+    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
+        
+        @self.app.get("/health")
+        async def health():
+            return {
+                "status": "healthy",
+                "directories": list(self.directories.keys()),
+                "ssl_enabled": self.security.ssl_enabled,
+                "auth_required": bool(security),
+                "directory_browsing": self.enable_directory_browsing
+            }
+        
+        @self.app.get("/")
+        async def root():
+            """Root endpoint showing available directories"""
+            html = """
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>SignalWire Web Service</title>
+                <style>
+                    body { font-family: sans-serif; margin: 40px; }
+                    h1 { color: #333; }
+                    ul { list-style: none; padding: 0; }
+                    li { padding: 10px 0; }
+                    a { text-decoration: none; color: #0066cc; font-size: 18px; }
+                    a:hover { text-decoration: underline; }
+                    .path { color: #666; font-size: 14px; }
+                </style>
+            </head>
+            <body>
+                <h1>SignalWire Web Service</h1>
+                <h2>Available Directories:</h2>
+                <ul>
+            """
+            
+            for route, local_path in self.directories.items():
+                html += f'<li>📁 <a href="{route}">{route}</a> <span class="path">→ {local_path}</span></li>'
+            
+            html += """
+                </ul>
+            </body>
+            </html>
+            """
+            
+            if HTMLResponse:
+                return HTMLResponse(content=html)
+            else:
+                return {"directories": list(self.directories.keys())}
+    
+    def _mount_directories(self):
+        """Mount static file directories"""
+        if not self.app or not StaticFiles:
+            return
+        
+        # Create security dependency if HTTPBasic is available
+        security = HTTPBasic() if HTTPBasic else None
+        
+        for route, directory in self.directories.items():
+            # Ensure directory exists
+            dir_path = Path(directory)
+            if not dir_path.exists():
+                logger.warning(f"Directory does not exist: {directory}")
+                continue
+            
+            if not dir_path.is_dir():
+                logger.warning(f"Path is not a directory: {directory}")
+                continue
+            
+            # Normalize route
+            if not route.startswith('/'):
+                route = '/' + route
+            
+            logger.info(f"Mounting directory {directory} at route {route}")
+            
+            # Create custom static file handler with our security checks
+            @self.app.get(f"{route}/{{file_path:path}}")
+            async def serve_file(
+                file_path: str,
+                request: Request,
+                credentials: HTTPBasicCredentials = None if not security else Depends(security),
+                route=route,
+                directory=directory
+            ):
+                """Serve files with security checks"""
+                if security:
+                    self._get_current_username(credentials)
+                
+                # Build full file path
+                full_path = Path(directory) / file_path
+                
+                # Security: Prevent path traversal
+                try:
+                    full_path = full_path.resolve()
+                    dir_path = Path(directory).resolve()
+                    if not str(full_path).startswith(str(dir_path)):
+                        raise HTTPException(status_code=403, detail="Access denied")
+                except Exception:
+                    raise HTTPException(status_code=403, detail="Invalid path")
+                
+                # Check if path exists
+                if not full_path.exists():
+                    raise HTTPException(status_code=404, detail="File not found")
+                
+                # Handle directory requests
+                if full_path.is_dir():
+                    if not self.enable_directory_browsing:
+                        # Try to serve index.html if it exists
+                        index_path = full_path / "index.html"
+                        if index_path.exists() and self._is_file_allowed(index_path):
+                            return FileResponse(index_path)
+                        else:
+                            raise HTTPException(status_code=403, detail="Directory browsing disabled")
+                    else:
+                        # Generate directory listing
+                        html = self._generate_directory_listing(full_path, request.url.path)
+                        if HTMLResponse:
+                            return HTMLResponse(content=html)
+                        else:
+                            raise HTTPException(status_code=403, detail="Directory browsing not available")
+                
+                # Check if file is allowed
+                if not self._is_file_allowed(full_path):
+                    raise HTTPException(status_code=403, detail="File type not allowed")
+                
+                # Serve the file
+                mime_type = mimetypes.guess_type(str(full_path))[0] or 'application/octet-stream'
+                
+                if FileResponse:
+                    return FileResponse(
+                        full_path,
+                        media_type=mime_type,
+                        headers={
+                            "Cache-Control": "public, max-age=3600",
+                            "X-Content-Type-Options": "nosniff"
+                        }
+                    )
+                else:
+                    # Fallback if FileResponse not available
+                    with open(full_path, 'rb') as f:
+                        content = f.read()
+                    return Response(
+                        content=content,
+                        media_type=mime_type,
+                        headers={
+                            "Cache-Control": "public, max-age=3600",
+                            "X-Content-Type-Options": "nosniff"
+                        }
+                    )
+    
+    def add_directory(self, route: str, directory: str) -> None:
+        """
+        Add a new directory to serve
+        
+        Args:
+            route: URL path to mount at (e.g., "/docs")
+            directory: Local directory path to serve
+        """
+        # Normalize route
+        if not route.startswith('/'):
+            route = '/' + route
+        
+        # Verify directory exists
+        dir_path = Path(directory)
+        if not dir_path.exists():
+            raise ValueError(f"Directory does not exist: {directory}")
+        
+        if not dir_path.is_dir():
+            raise ValueError(f"Path is not a directory: {directory}")
+        
+        self.directories[route] = directory
+        
+        # If app is already running, mount the new directory
+        if self.app:
+            self._mount_directories()
+    
+    def remove_directory(self, route: str) -> None:
+        """
+        Remove a directory from being served
+        
+        Args:
+            route: URL path to remove
+        """
+        # Normalize route
+        if not route.startswith('/'):
+            route = '/' + route
+        
+        if route in self.directories:
+            del self.directories[route]
+    
+    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_web_service",
+            url=startup_url,
+            ssl_enabled=bool(ssl_kwargs),
+            directories=list(self.directories.keys()),
+            username=username
+        )
+        
+        # Print user-friendly startup message
+        print(f"\nSignalWire Web Service starting...")
+        print(f"URL: {startup_url}")
+        print(f"Directories: {', '.join(self.directories.keys()) if self.directories else 'None'}")
+        print(f"Basic Auth: {username}:{password}")
+        print(f"Directory Browsing: {'Enabled' if self.enable_directory_browsing else 'Disabled'}")
+        if ssl_kwargs:
+            print(f"SSL: Enabled")
+        print("")
+        
+        try:
+            import uvicorn
+            uvicorn.run(
+                self.app, 
+                host=host, 
+                port=port,
+                **ssl_kwargs
+            )
+        except ImportError:
+            raise RuntimeError("uvicorn not available. Cannot start HTTP service.")
+    
+    def stop(self):
+        """Stop the service (placeholder for cleanup)"""
+        pass

{signalwire_agents-0.1.43.dist-info → signalwire_agents-0.1.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: signalwire_agents
-Version: 0.1.43
+Version: 0.1.45
 Summary: SignalWire AI Agents SDK
 Author-email: SignalWire Team <info@signalwire.com>
 License: MIT

{signalwire_agents-0.1.43.dist-info → signalwire_agents-0.1.45.dist-info}/RECORD

@@ -1,4 +1,4 @@
-signalwire_agents/__init__.py,sha256=JEGLCo_LLxcqdvVcd64XAfHEJ2pfoanrZ-AS_691Mqc,4923
+signalwire_agents/__init__.py,sha256=0r2v5Nsh4xlPBc9pra7UTAgiTozjZ0tI5tSRUtG68_U,5031
 signalwire_agents/agent_server.py,sha256=x9HyWia8D3r6KMqY-Q4DtNVivfJWLTx8B-KzUI8okuA,26880
 signalwire_agents/schema.json,sha256=6-7ccbt39iM1CO36dOfvupRPfd0gnQ0XoAdyo-EFyjo,238042
 signalwire_agents/agents/bedrock.py,sha256=J582gooNtxtep4xdVOfyDzRtHp_XrurPMS93xf2Xod0,10836
@@ -24,7 +24,7 @@ signalwire_agents/cli/simulation/data_generation.py,sha256=pxa9aJ6XkI0O8yAIGvBTU
 signalwire_agents/cli/simulation/data_overrides.py,sha256=3_3pT6j-q2gRufPX2bZ1BrmY7u1IdloLooKAJil33vI,6319
 signalwire_agents/cli/simulation/mock_env.py,sha256=fvaR_xdLMm8AbpNUbTJOFG9THcti3Zds-0QNDbKMaYk,10249
 signalwire_agents/core/__init__.py,sha256=xjPq8DmUnWYUG28sd17n430VWPmMH9oZ9W14gYwG96g,806
-signalwire_agents/core/agent_base.py,sha256=Wy1xAyJgquI4Cabss1lddoNonJzOYeo3VtY9suEFDFA,48634
+signalwire_agents/core/agent_base.py,sha256=SGaPKnjblJcjkz0bujiNezyelyJcaP72c-e33cAfhtA,48963
 signalwire_agents/core/auth_handler.py,sha256=jXrof9WZ1W9qqlQT9WElcmSRafL2kG7207x5SqWN9MU,8481
 signalwire_agents/core/config_loader.py,sha256=rStVRRUaeMGrMc44ocr0diMQQARZhbKqwMqQ6kqUNos,8722
 signalwire_agents/core/contexts.py,sha256=g9FgOGMfGCUWlm57YZcv7CvOf-Ub9FdKZIOMu14ADfE,24428
@@ -55,12 +55,12 @@ signalwire_agents/core/agent/tools/registry.py,sha256=CgsCUMWBV4Use1baNl2KLYS2ew
 signalwire_agents/core/mixins/__init__.py,sha256=NsFpfF7TDP_lNR0Riw4Nbvt4fDbv_A3OoVbBqRrtXQM,652
 signalwire_agents/core/mixins/ai_config_mixin.py,sha256=kT-xVVWMIE6RQe6qQFCRYxli345bxOs5uS1dCtMTeTc,18232
 signalwire_agents/core/mixins/auth_mixin.py,sha256=Y9kR423-76U_pKL7KXzseeXX2a-4WxNWyo3odS7TDQM,9879
-signalwire_agents/core/mixins/prompt_mixin.py,sha256=2cAJpp3Ka-fmgpAg201xeTy-xps99k0vlP7YyqZiCnw,13374
+signalwire_agents/core/mixins/prompt_mixin.py,sha256=bEsuw9J2F_upFYI02KyC7o2eGZjwOKQ352rmJBZirAM,13729
 signalwire_agents/core/mixins/serverless_mixin.py,sha256=QIIbl_-16XFJi5aqrWpNzORbyCJQmhaplWXnW6U9i68,16137
 signalwire_agents/core/mixins/skill_mixin.py,sha256=Qz3RKPmq_iMY4NecyxOHk3dW3W-O4iEm2ahhMjAcqRs,1861
 signalwire_agents/core/mixins/state_mixin.py,sha256=q3achpyUYZKuJaqKf12O22FXpSsNNsMEonSvlpSHCkA,6594
 signalwire_agents/core/mixins/tool_mixin.py,sha256=6CaNdaspHcfte0qSB_bSN8PTsqxRZzL_AXYk8QoWyXE,8660
-signalwire_agents/core/mixins/web_mixin.py,sha256=BUzmTkPIHGfitzbn1p94SDSqp-7x_IesjliypagB4oI,50324
+signalwire_agents/core/mixins/web_mixin.py,sha256=2Tj0mulcjiUBuqHnJ76UHc5C2L5xV91HKyxfG3lNj4k,50612
 signalwire_agents/core/security/__init__.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/core/security/session_manager.py,sha256=s5hXYcFnrsYFoyo-zcN7EJy-wInZQI_cWTBHX9MxHR4,9164
 signalwire_agents/prefabs/__init__.py,sha256=MW11J63XH7KxF2MWguRsMFM9iqMWexaEO9ynDPL_PDM,715
@@ -126,9 +126,11 @@ signalwire_agents/utils/pom_utils.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_Pu
 signalwire_agents/utils/schema_utils.py,sha256=i4okv_O9bUApwT_jJf4Yoij3bLCrGrW3DC-vzSy2RuY,16392
 signalwire_agents/utils/token_generators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
 signalwire_agents/utils/validators.py,sha256=4Mr7baQ_xR_hfJ72YxQRAT_GFa663YjFX_PumJ35Xds,191
-signalwire_agents-0.1.43.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
-signalwire_agents-0.1.43.dist-info/METADATA,sha256=kgPeaomBUFGZXUo9UcFBL9oRYI6taPxbbgJjgKIzxcI,41281
-signalwire_agents-0.1.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-signalwire_agents-0.1.43.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
-signalwire_agents-0.1.43.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
-signalwire_agents-0.1.43.dist-info/RECORD,,
+signalwire_agents/web/__init__.py,sha256=XE_pSTY9Aalzr7J7wqFth1Zr3cccQHPPcF5HWNrOpz8,383
+signalwire_agents/web/web_service.py,sha256=a2PSHJgX1tlZr0Iz1A1UouZjXEePJAZL632evvLVM38,21071
+signalwire_agents-0.1.45.dist-info/licenses/LICENSE,sha256=NYvAsB-rTcSvG9cqHt9EUHAWLiA9YzM4Qfz-mPdvDR0,1067
+signalwire_agents-0.1.45.dist-info/METADATA,sha256=_UXOEqLIwgDb90G0K9fO95MKagAx-8VKp2UdLYX9_hs,41281
+signalwire_agents-0.1.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+signalwire_agents-0.1.45.dist-info/entry_points.txt,sha256=ZDT65zfTO_YyDzi_hwQbCxIhrUfu_t8RpNXMMXlUPWI,144
+signalwire_agents-0.1.45.dist-info/top_level.txt,sha256=kDGS6ZYv84K9P5Kyg9_S8P_pbUXoHkso0On_DB5bbWc,18
+signalwire_agents-0.1.45.dist-info/RECORD,,