signalwire-agents 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

signalwire_agents/cli/test_swaig.py

@@ -46,8 +46,14 @@ Examples:
     swaig-test examples/my_agent.py --dump-swml --raw | jq '.sections.main[1].ai.SWAIG.functions'
 """
 
+# CRITICAL: Set environment variable BEFORE any imports to suppress logs for --raw
 import sys
 import os
+
+if "--raw" in sys.argv or "--dump-swml" in sys.argv:
+    os.environ["SIGNALWIRE_LOG_MODE"] = "off"
+
+import warnings
 import json
 import importlib.util
 import argparse
@@ -56,13 +62,18 @@ import time
 import hashlib
 import re
 import requests
-import warnings
 from pathlib import Path
 from typing import Dict, Any, Optional, List, Tuple
 from datetime import datetime
 import logging
 import inspect
 
+# Store original print function before any potential suppression
+original_print = print
+
+# Add the parent directory to the path so we can import signalwire_agents
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
 try:
     # Try to import the AgentBase class
     from signalwire_agents.core.agent_base import AgentBase
@@ -72,22 +83,15 @@ except ImportError:
     AgentBase = None
     SwaigFunctionResult = None
 
-# Early setup for raw mode using the central logging system
-if "--raw" in sys.argv:
-    # Use the central logging system's OFF mode for raw output
-    # This eliminates all logging output without complex suppression hacks
-    os.environ["SIGNALWIRE_LOG_MODE"] = "off"
-    warnings.filterwarnings("ignore")
-
-# Store original print function before any potential suppression
-original_print = print
-
-# Add the parent directory to the path so we can import signalwire_agents
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from signalwire_agents import AgentBase
-from signalwire_agents.core.function_result import SwaigFunctionResult
-
+# Reset logging configuration if --raw flag was set
+# This must happen AFTER signalwire_agents imports but BEFORE any logging is used
+if "--raw" in sys.argv or "--dump-swml" in sys.argv:
+    try:
+        from signalwire_agents.core.logging_config import reset_logging_configuration, configure_logging
+        reset_logging_configuration()
+        configure_logging()  # Reconfigure with the new environment variable
+    except ImportError:
+        pass
 
 # ===== MOCK REQUEST OBJECTS FOR DYNAMIC AGENT TESTING =====
 
@@ -666,7 +670,6 @@ def handle_dump_swml(agent: 'AgentBase', args: argparse.Namespace) -> int:
         Exit code (0 for success, 1 for error)
     """
     if not args.raw:
-        print("\nGenerating SWML document...")
         if args.verbose:
             print(f"Agent: {agent.get_name()}")
             print(f"Route: {agent.route}")
@@ -767,20 +770,13 @@ def handle_dump_swml(agent: 'AgentBase', args: argparse.Namespace) -> int:
             # Output only the raw JSON for piping to jq/yq
             print(swml_doc)
         else:
-            # Normal output with headers
-            print("SWML Document:")
-            print("=" * 50)
-            print(swml_doc)
-            print("=" * 50)
-            
-            if args.verbose:
-                # Parse and show formatted JSON for better readability
-                try:
-                    swml_parsed = json.loads(swml_doc)
-                    print("\nFormatted SWML:")
-                    print(json.dumps(swml_parsed, indent=2))
-                except json.JSONDecodeError:
-                    print("\nNote: SWML document is not valid JSON format")
+            # Output formatted JSON (like raw but pretty-printed)
+            try:
+                swml_parsed = json.loads(swml_doc)
+                print(json.dumps(swml_parsed, indent=2))
+            except json.JSONDecodeError:
+                # If not valid JSON, show raw
+                print(swml_doc)
         
         return 0
         
@@ -1375,6 +1371,94 @@ def execute_external_webhook_function(func: 'SWAIGFunction', function_name: str,
         return {"error": error_msg}
 
 
+def display_agent_tools(agent: 'AgentBase', verbose: bool = False) -> None:
+    """
+    Display the available SWAIG functions for an agent
+    
+    Args:
+        agent: The agent instance
+        verbose: Whether to show verbose details
+    """
+    print("\nAvailable SWAIG functions:")
+    if hasattr(agent, '_swaig_functions') and agent._swaig_functions:
+        for name, func in agent._swaig_functions.items():
+            if isinstance(func, dict):
+                # DataMap function
+                description = func.get('description', 'DataMap function (serverless)')
+                print(f"  {name} - {description}")
+                
+                # Show parameters for DataMap functions
+                if 'parameters' in func and func['parameters']:
+                    params = func['parameters']
+                    # Handle both formats: direct properties dict or full schema
+                    if 'properties' in params:
+                        properties = params['properties']
+                        required_fields = params.get('required', [])
+                    else:
+                        properties = params
+                        required_fields = []
+                    
+                    if properties:
+                        print(f"    Parameters:")
+                        for param_name, param_def in properties.items():
+                            param_type = param_def.get('type', 'unknown')
+                            param_desc = param_def.get('description', 'No description')
+                            is_required = param_name in required_fields
+                            required_marker = " (required)" if is_required else ""
+                            print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
+                    else:
+                        print(f"    Parameters: None")
+                else:
+                    print(f"    Parameters: None")
+                    
+                if verbose:
+                    print(f"    Config: {json.dumps(func, indent=6)}")
+            else:
+                # Regular SWAIG function
+                func_type = ""
+                if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
+                    func_type = " (EXTERNAL webhook)"
+                elif hasattr(func, 'webhook_url') and func.webhook_url:
+                    func_type = " (webhook)"
+                else:
+                    func_type = " (LOCAL webhook)"
+                
+                print(f"  {name} - {func.description}{func_type}")
+                
+                # Show external URL if applicable
+                if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
+                    print(f"    External URL: {func.webhook_url}")
+                
+                # Show parameters
+                if hasattr(func, 'parameters') and func.parameters:
+                    params = func.parameters
+                    # Handle both formats: direct properties dict or full schema
+                    if 'properties' in params:
+                        properties = params['properties']
+                        required_fields = params.get('required', [])
+                    else:
+                        properties = params
+                        required_fields = []
+                    
+                    if properties:
+                        print(f"    Parameters:")
+                        for param_name, param_def in properties.items():
+                            param_type = param_def.get('type', 'unknown')
+                            param_desc = param_def.get('description', 'No description')
+                            is_required = param_name in required_fields
+                            required_marker = " (required)" if is_required else ""
+                            print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
+                    else:
+                        print(f"    Parameters: None")
+                else:
+                    print(f"    Parameters: None")
+                    
+                if verbose:
+                    print(f"    Function object: {func}")
+    else:
+        print("  No SWAIG functions registered")
+
+
 def discover_agents_in_file(agent_path: str) -> List[Dict[str, Any]]:
     """
     Discover all available agents in a Python file without instantiating them
@@ -2315,7 +2399,29 @@ Examples:
                     
                     print()
                 
-                if len(agents) > 1:
+                # Show tools if there's only one agent or if --agent-class is specified
+                show_tools = False
+                selected_agent = None
+                
+                if len(agents) == 1:
+                    # Single agent - show tools automatically
+                    show_tools = True
+                    selected_agent = agents[0]['object']
+                    print("This file contains a single agent, no --agent-class needed.")
+                elif args.agent_class:
+                    # Specific agent class requested - show tools for that agent
+                    for agent_info in agents:
+                        if agent_info['class_name'] == args.agent_class:
+                            show_tools = True
+                            selected_agent = agent_info['object']
+                            break
+                    
+                    if not selected_agent:
+                        print(f"Error: Agent class '{args.agent_class}' not found.")
+                        print(f"Available agents: {[a['class_name'] for a in agents]}")
+                        return 1
+                else:
+                    # Multiple agents, no specific class - show usage examples
                     print("To use a specific agent with this tool:")
                     print(f"  swaig-test {args.agent_path} [tool_name] [args] --agent-class <AgentClassName>")
                     print()
@@ -2324,8 +2430,24 @@ Examples:
                         print(f"  swaig-test {args.agent_path} --list-tools --agent-class {agent_info['class_name']}")
                         print(f"  swaig-test {args.agent_path} --dump-swml --agent-class {agent_info['class_name']}")
                     print()
-                else:
-                    print("This file contains a single agent, no --agent-class needed.")
+                
+                # Show tools if we have a selected agent
+                if show_tools and selected_agent:
+                    try:
+                        # If it's a class, try to instantiate it
+                        if not isinstance(selected_agent, AgentBase):
+                            if isinstance(selected_agent, type) and issubclass(selected_agent, AgentBase):
+                                selected_agent = selected_agent()
+                            else:
+                                print(f"Warning: Cannot instantiate agent to show tools")
+                                return 0
+                        
+                        display_agent_tools(selected_agent, args.verbose)
+                    except Exception as e:
+                        print(f"Warning: Could not load agent tools: {e}")
+                        if args.verbose:
+                            import traceback
+                            traceback.print_exc()
                 
                 return 0
                 
@@ -2374,84 +2496,7 @@ Examples:
         
         # List tools if requested
         if args.list_tools:
-            print("\nAvailable SWAIG functions:")
-            if hasattr(agent, '_swaig_functions') and agent._swaig_functions:
-                for name, func in agent._swaig_functions.items():
-                    if isinstance(func, dict):
-                        # DataMap function
-                        description = func.get('description', 'DataMap function (serverless)')
-                        print(f"  {name} - {description}")
-                        
-                        # Show parameters for DataMap functions
-                        if 'parameters' in func and func['parameters']:
-                            params = func['parameters']
-                            # Handle both formats: direct properties dict or full schema
-                            if 'properties' in params:
-                                properties = params['properties']
-                                required_fields = params.get('required', [])
-                            else:
-                                properties = params
-                                required_fields = []
-                            
-                            if properties:
-                                print(f"    Parameters:")
-                                for param_name, param_def in properties.items():
-                                    param_type = param_def.get('type', 'unknown')
-                                    param_desc = param_def.get('description', 'No description')
-                                    is_required = param_name in required_fields
-                                    required_marker = " (required)" if is_required else ""
-                                    print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
-                            else:
-                                print(f"    Parameters: None")
-                        else:
-                            print(f"    Parameters: None")
-                            
-                        if args.verbose:
-                            print(f"    Config: {json.dumps(func, indent=6)}")
-                    else:
-                        # Regular SWAIG function
-                        func_type = ""
-                        if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
-                            func_type = " (EXTERNAL webhook)"
-                        elif hasattr(func, 'webhook_url') and func.webhook_url:
-                            func_type = " (webhook)"
-                        else:
-                            func_type = " (LOCAL webhook)"
-                        
-                        print(f"  {name} - {func.description}{func_type}")
-                        
-                        # Show external URL if applicable
-                        if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
-                            print(f"    External URL: {func.webhook_url}")
-                        
-                        # Show parameters
-                        if hasattr(func, 'parameters') and func.parameters:
-                            params = func.parameters
-                            # Handle both formats: direct properties dict or full schema
-                            if 'properties' in params:
-                                properties = params['properties']
-                                required_fields = params.get('required', [])
-                            else:
-                                properties = params
-                                required_fields = []
-                            
-                            if properties:
-                                print(f"    Parameters:")
-                                for param_name, param_def in properties.items():
-                                    param_type = param_def.get('type', 'unknown')
-                                    param_desc = param_def.get('description', 'No description')
-                                    is_required = param_name in required_fields
-                                    required_marker = " (required)" if is_required else ""
-                                    print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
-                            else:
-                                print(f"    Parameters: None")
-                        else:
-                            print(f"    Parameters: None")
-                            
-                        if args.verbose:
-                            print(f"    Function object: {func}")
-            else:
-                print("  No SWAIG functions registered")
+            display_agent_tools(agent, args.verbose)
             return 0
         
         # Dump SWML if requested
@@ -2606,4 +2651,4 @@ def console_entry_point():
 
 
 if __name__ == "__main__":
-    sys.exit(main()) 
+    sys.exit(main()) 

signalwire_agents/core/agent_base.py

@@ -44,31 +44,7 @@ except ImportError:
         "uvicorn is required. Install it with: pip install uvicorn"
     )
 
-try:
-    import structlog
-    # Configure structlog only if not already configured
-    if not structlog.is_configured():
-        structlog.configure(
-            processors=[
-                structlog.stdlib.filter_by_level,
-                structlog.stdlib.add_logger_name,
-                structlog.stdlib.add_log_level,
-                structlog.stdlib.PositionalArgumentsFormatter(),
-                structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S"),
-                structlog.processors.StackInfoRenderer(),
-                structlog.processors.format_exc_info,
-                structlog.processors.UnicodeDecoder(),
-                structlog.dev.ConsoleRenderer()
-            ],
-            context_class=dict,
-            logger_factory=structlog.stdlib.LoggerFactory(),
-            wrapper_class=structlog.stdlib.BoundLogger,
-            cache_logger_on_first_use=True,
-        )
-except ImportError:
-    raise ImportError(
-        "structlog is required. Install it with: pip install structlog"
-    )
+
 
 from signalwire_agents.core.pom_builder import PomBuilder
 from signalwire_agents.core.swaig_function import SWAIGFunction
@@ -82,8 +58,8 @@ from signalwire_agents.core.skill_manager import SkillManager
 from signalwire_agents.utils.schema_utils import SchemaUtils
 from signalwire_agents.core.logging_config import get_logger, get_execution_mode
 
-# Create a logger
-logger = structlog.get_logger("agent_base")
+# Create a logger using centralized system
+logger = get_logger("agent_base")
 
 class EphemeralAgentConfig:
     """
@@ -1363,8 +1339,8 @@ class AgentBase(SWMLService):
                     host = self.host
                 base_url = f"http://{host}:{self.port}{self.route}"
             
-        # Add auth if requested (only for server mode)
-        if include_auth and mode == 'server':
+        # Add auth if requested (applies to all modes now)
+        if include_auth:
             username, password = self._basic_auth
             url = urlparse(base_url)
             return url._replace(netloc=f"{username}:{password}@{url.netloc}").geturl()
@@ -1386,11 +1362,8 @@ class AgentBase(SWMLService):
         mode = get_execution_mode()
         
         if mode != 'server':
-            # In serverless mode, use the serverless-appropriate URL
-            base_url = self.get_full_url()
-            
-            # For serverless, we don't need auth in webhook URLs since auth is handled differently
-            # and we want to return the actual platform URL
+            # In serverless mode, use the serverless-appropriate URL with auth
+            base_url = self.get_full_url(include_auth=True)
             
             # Ensure the endpoint has a trailing slash to prevent redirects
             if endpoint in ["swaig", "post_prompt"]:
@@ -2053,8 +2026,6 @@ class AgentBase(SWMLService):
         Returns:
             Function execution result
         """
-        import structlog
-        
         # Use the existing logger
         req_log = self.log.bind(
             endpoint="serverless_swaig",
@@ -2227,8 +2198,6 @@ class AgentBase(SWMLService):
                 
                 self.log.info("callback_endpoint_registered", path=callback_path)
     
-    @classmethod
-
     # ----------------------------------------------------------------------
     # AI Verb Configuration Methods
     # ----------------------------------------------------------------------

signalwire_agents/core/logging_config.py

@@ -89,12 +89,44 @@ class StructuredLoggerWrapper:
     # Also support the 'warn' alias
     warn = warning
     
+    def bind(self, **kwargs) -> 'StructuredLoggerWrapper':
+        """
+        Create a new logger instance with bound context data
+        
+        This maintains compatibility with structlog's bind() method.
+        The bound data will be included in all subsequent log messages.
+        """
+        # Create a new wrapper that includes the bound context
+        return BoundStructuredLoggerWrapper(self._logger, kwargs)
+    
     # Support direct access to underlying logger attributes if needed
     def __getattr__(self, name: str) -> Any:
         """Delegate any unknown attributes to the underlying logger"""
         return getattr(self._logger, name)
 
 
+class BoundStructuredLoggerWrapper(StructuredLoggerWrapper):
+    """
+    A structured logger wrapper that includes bound context data in all messages
+    """
+    
+    def __init__(self, logger: logging.Logger, bound_data: Dict[str, Any]):
+        super().__init__(logger)
+        self._bound_data = bound_data
+    
+    def _format_structured_message(self, message: str, **kwargs) -> str:
+        """Format a message with both bound data and additional keyword arguments"""
+        # Combine bound data with additional kwargs
+        all_kwargs = {**self._bound_data, **kwargs}
+        return super()._format_structured_message(message, **all_kwargs)
+    
+    def bind(self, **kwargs) -> 'BoundStructuredLoggerWrapper':
+        """Create a new logger with additional bound context"""
+        # Combine existing bound data with new data
+        new_bound_data = {**self._bound_data, **kwargs}
+        return BoundStructuredLoggerWrapper(self._logger, new_bound_data)
+
+
 def get_execution_mode() -> str:
     """
     Determine the execution mode based on environment variables
@@ -111,6 +143,16 @@ def get_execution_mode() -> str:
     return 'server'
 
 
+def reset_logging_configuration():
+    """
+    Reset the logging configuration flag to allow reconfiguration
+    
+    This is useful when environment variables change after initial configuration.
+    """
+    global _logging_configured
+    _logging_configured = False
+
+
 def configure_logging():
     """
     Configure logging system once, globally, based on environment variables
@@ -182,31 +224,39 @@ def _configure_off_mode():
 
 
 def _configure_stderr_mode(log_level: str):
-    """Configure logging to stderr"""
+    """Configure logging to stderr with colored formatting"""
     # Clear existing handlers
     logging.getLogger().handlers.clear()
     
     # Convert log level
     numeric_level = getattr(logging, log_level.upper(), logging.INFO)
     
-    # Configure to stderr
-    logging.basicConfig(
-        stream=sys.stderr,
-        level=numeric_level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+    # Create handler with colored formatter
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(ColoredFormatter())
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    root_logger.addHandler(handler)
 
 
 def _configure_default_mode(log_level: str):
-    """Configure standard logging behavior"""
+    """Configure standard logging behavior with colored formatting"""
+    # Clear existing handlers
+    logging.getLogger().handlers.clear()
+    
     # Convert log level
     numeric_level = getattr(logging, log_level.upper(), logging.INFO)
     
-    # Configure standard logging
-    logging.basicConfig(
-        level=numeric_level,
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+    # Create handler with colored formatter
+    handler = logging.StreamHandler()
+    handler.setFormatter(ColoredFormatter())
+    
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(numeric_level)
+    root_logger.addHandler(handler)
 
 
 def get_logger(name: str) -> StructuredLoggerWrapper:
@@ -229,4 +279,83 @@ def get_logger(name: str) -> StructuredLoggerWrapper:
     python_logger = logging.getLogger(name)
     
     # Wrap it with our structured logging interface
-    return StructuredLoggerWrapper(python_logger) 
+    return StructuredLoggerWrapper(python_logger)
+
+
+class ColoredFormatter(logging.Formatter):
+    """
+    A beautiful colored logging formatter that makes logs easy to read and visually appealing
+    """
+    
+    # ANSI color codes
+    COLORS = {
+        'DEBUG': '\033[36m',     # Cyan
+        'INFO': '\033[32m',      # Green  
+        'WARNING': '\033[33m',   # Yellow
+        'ERROR': '\033[31m',     # Red
+        'CRITICAL': '\033[35m',  # Magenta
+        'RESET': '\033[0m',      # Reset
+        'BOLD': '\033[1m',       # Bold
+        'DIM': '\033[2m',        # Dim
+        'WHITE': '\033[37m',     # White
+        'BLUE': '\033[34m',      # Blue
+        'BLACK': '\033[30m',     # Black (for brackets)
+    }
+    
+    def __init__(self):
+        super().__init__()
+    
+    def format(self, record):
+        # Check if we should use colors (not in raw mode, and stdout is a tty)
+        use_colors = (
+            hasattr(sys.stdout, 'isatty') and sys.stdout.isatty() and
+            os.getenv('SIGNALWIRE_LOG_MODE') != 'off' and
+            '--raw' not in sys.argv and '--dump-swml' not in sys.argv
+        )
+        
+        if use_colors:
+            # Get colors
+            level_color = self.COLORS.get(record.levelname, self.COLORS['WHITE'])
+            reset = self.COLORS['RESET']
+            dim = self.COLORS['DIM']
+            bold = self.COLORS['BOLD']
+            blue = self.COLORS['BLUE']
+            black = self.COLORS['BLACK']
+            
+            # Format timestamp in a compact, readable way
+            timestamp = self.formatTime(record, '%H:%M:%S')
+            
+            # Format level with appropriate color and consistent width
+            level_name = f"{level_color}{record.levelname:<8}{reset}"
+            
+            # Format logger name - keep it short and readable
+            logger_name = record.name
+            if len(logger_name) > 15:
+                # Truncate long logger names but keep the end (most specific part)
+                logger_name = "..." + logger_name[-12:]
+            
+            # Get function and line info if available
+            func_info = ""
+            if hasattr(record, 'funcName') and hasattr(record, 'lineno'):
+                func_name = getattr(record, 'funcName', '')
+                line_no = getattr(record, 'lineno', 0)
+                if func_name and func_name != '<module>':
+                    func_info = f" {dim}({func_name}:{line_no}){reset}"
+            
+            # Format the message
+            message = record.getMessage()
+            
+            # Create the final formatted message with a clean, readable layout
+            formatted = (
+                f"{black}[{reset}{dim}{timestamp}{reset}{black}]{reset} "
+                f"{level_name} "
+                f"{blue}{logger_name:<15}{reset}"
+                f"{func_info} "
+                f"{message}"
+            )
+            
+            return formatted
+        else:
+            # Non-colored format (fallback for files, pipes, etc.)
+            timestamp = self.formatTime(record, '%Y-%m-%d %H:%M:%S')
+            return f"{timestamp} {record.levelname:<8} {record.name} {record.getMessage()}" 

signalwire_agents/core/skill_manager.py

@@ -8,7 +8,7 @@ See LICENSE file in the project root for full license information.
 """
 
 from typing import Dict, List, Type, Any, Optional
-import logging
+from signalwire_agents.core.logging_config import get_logger
 from signalwire_agents.core.skill_base import SkillBase
 
 class SkillManager:
@@ -17,7 +17,7 @@ class SkillManager:
     def __init__(self, agent):
         self.agent = agent
         self.loaded_skills: Dict[str, SkillBase] = {}
-        self.logger = logging.getLogger("skill_manager")
+        self.logger = get_logger("skill_manager")
         
     def load_skill(self, skill_name: str, skill_class: Type[SkillBase] = None, params: Optional[Dict[str, Any]] = None) -> tuple[bool, str]:
         """

signalwire_agents/core/swaig_function.py

@@ -15,6 +15,8 @@ from typing import Dict, Any, Optional, Callable, List, Type, Union
 import inspect
 import logging
 
+# Import here to avoid circular imports
+from signalwire_agents.core.function_result import SwaigFunctionResult
 
 class SWAIGFunction:
     """
@@ -101,9 +103,6 @@ class SWAIGFunction:
             # Call the handler with both args and raw_data
             result = self.handler(args, raw_data)
                 
-            # Import here to avoid circular imports
-            from signalwire_agents.core.function_result import SwaigFunctionResult
-            
             # Handle different result types - everything must end up as a SwaigFunctionResult
             if isinstance(result, SwaigFunctionResult):
                 # Already a SwaigFunctionResult - just convert to dict