signalwire-agents 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

signalwire_agents/cli/core/service_loader.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+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.
+"""
+
+"""
+Service discovery and loading functionality - new simplified approach
+"""
+
+import importlib.util
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Callable
+import asyncio
+import sys
+import io
+import contextlib
+
+# Import after checking if available
+try:
+    from signalwire_agents.core.agent_base import AgentBase
+    from signalwire_agents.core.swml_service import SWMLService
+    from fastapi import Request, Response
+    DEPENDENCIES_AVAILABLE = True
+except ImportError:
+    AgentBase = None
+    SWMLService = None
+    Request = None
+    Response = None
+    DEPENDENCIES_AVAILABLE = False
+
+
+class ServiceCapture:
+    """Captures SWMLService instances when they try to run/serve"""
+    
+    def __init__(self):
+        self.captured_services: List[SWMLService] = []
+        self.original_methods = {}
+        
+    def capture(self, service_path: str, suppress_output: bool = False) -> List[SWMLService]:
+        """
+        Execute a service file and capture any services that try to run
+        
+        Args:
+            service_path: Path to the Python file
+            suppress_output: If True, suppress stdout during module execution
+            
+        Returns:
+            List of captured SWMLService instances
+        """
+        if not DEPENDENCIES_AVAILABLE:
+            raise ImportError("Required dependencies not available. Please install signalwire-agents package.")
+            
+        service_path = Path(service_path).resolve()
+        
+        if not service_path.exists():
+            raise FileNotFoundError(f"Service file not found: {service_path}")
+            
+        if not service_path.suffix == '.py':
+            raise ValueError(f"Service file must be a Python file (.py): {service_path}")
+        
+        # Reset captured services
+        self.captured_services = []
+        
+        # Apply patches
+        self._apply_patches()
+        
+        # Context manager for optional stdout suppression
+        stdout_context = io.StringIO() if suppress_output else None
+        
+        try:
+            with contextlib.redirect_stdout(stdout_context) if suppress_output else contextlib.nullcontext():
+                # Load and execute the module
+                spec = importlib.util.spec_from_file_location("__main__", service_path)
+                module = importlib.util.module_from_spec(spec)
+                
+                # Set __name__ to "__main__" to trigger if __name__ == "__main__": blocks
+                module.__name__ = "__main__"
+                
+                try:
+                    spec.loader.exec_module(module)
+                except Exception as e:
+                    # Module might have called run/serve which we intercepted
+                    if not self.captured_services:
+                        # If we didn't capture anything, the error is real
+                        raise ImportError(f"Failed to load service module: {e}")
+        finally:
+            # Always restore original methods
+            self._restore_patches()
+            
+        return self.captured_services
+    
+    def _apply_patches(self):
+        """Apply patches to capture services"""
+        
+        # Store reference to self for use in closures
+        capture_self = self
+        
+        def mock_run(service_instance, *args, **kwargs):
+            """Capture service when run() is called"""
+            capture_self.captured_services.append(service_instance)
+            # Don't print during stdout suppression
+            # Don't actually run - we're just capturing
+            return service_instance
+            
+        def mock_serve(service_instance, *args, **kwargs):
+            """Capture service when serve() is called"""
+            capture_self.captured_services.append(service_instance)
+            # Don't print during stdout suppression
+            # Don't actually serve - we're just capturing
+            return service_instance
+            
+        # Apply patches to both SWMLService and AgentBase
+        for base_class in [SWMLService, AgentBase]:
+            if base_class:
+                if hasattr(base_class, 'run'):
+                    self.original_methods[(base_class, 'run')] = base_class.run
+                    base_class.run = mock_run
+                    
+                if hasattr(base_class, 'serve'):
+                    self.original_methods[(base_class, 'serve')] = base_class.serve
+                    base_class.serve = mock_serve
+    
+    def _restore_patches(self):
+        """Restore original methods"""
+        for (base_class, method_name), original_method in self.original_methods.items():
+            setattr(base_class, method_name, original_method)
+        self.original_methods.clear()
+
+
+async def simulate_request_to_service(
+    service: SWMLService,
+    method: str = "POST",
+    body: Optional[dict] = None,
+    query_params: Optional[dict] = None,
+    headers: Optional[dict] = None
+) -> dict:
+    """
+    Simulate a request to a SWMLService instance
+    
+    Args:
+        service: The SWMLService instance
+        method: HTTP method (GET or POST)
+        body: Request body for POST requests
+        query_params: Query parameters
+        headers: Request headers
+        
+    Returns:
+        The service's response as a dict
+    """
+    # Create a mock request
+    from signalwire_agents.cli.simulation.mock_env import create_mock_request
+    
+    request = create_mock_request(
+        method=method,
+        headers=headers or {},
+        query_params=query_params or {},
+        body=body or {}
+    )
+    
+    # Create a mock response
+    response = Response()
+    
+    # Call the service's request handler
+    result = await service._handle_request(request, response)
+    
+    # If result is a Response object, extract the content
+    if hasattr(result, 'body'):
+        # FastAPI Response
+        import json
+        return json.loads(result.body.decode())
+    elif isinstance(result, dict):
+        return result
+    else:
+        # Try to get content from response
+        return {"error": "Unable to parse response"}
+
+
+def load_and_simulate_service(
+    service_path: str,
+    route: Optional[str] = None,
+    method: str = "POST",
+    body: Optional[dict] = None,
+    query_params: Optional[dict] = None,
+    headers: Optional[dict] = None,
+    suppress_output: bool = False
+) -> dict:
+    """
+    Load a service file and simulate a request to it
+    
+    This is the main entry point that combines loading and request simulation
+    
+    Args:
+        service_path: Path to the service file
+        route: Optional route to request (for multi-service files)
+        method: HTTP method
+        body: Request body
+        query_params: Query parameters
+        headers: Request headers
+        
+    Returns:
+        The service's response
+    """
+    # Capture services from the file
+    capturer = ServiceCapture()
+    services = capturer.capture(service_path, suppress_output=suppress_output)
+    
+    if not services:
+        raise ValueError(f"No services found in {service_path}")
+    
+    # Select the appropriate service
+    if len(services) == 1:
+        service = services[0]
+    else:
+        # Multiple services - need to select by route
+        if not route:
+            # List available routes
+            routes = [s.route for s in services]
+            raise ValueError(
+                f"Multiple services found. Please specify a route.\n"
+                f"Available routes: {', '.join(routes)}"
+            )
+        
+        # Find service by route
+        service = None
+        for s in services:
+            if s.route == route:
+                service = s
+                break
+                
+        if not service:
+            available = [s.route for s in services]
+            raise ValueError(
+                f"No service found for route '{route}'.\n"
+                f"Available routes: {', '.join(available)}"
+            )
+    
+    # Simulate the request
+    return asyncio.run(simulate_request_to_service(
+        service,
+        method=method,
+        body=body,
+        query_params=query_params,
+        headers=headers
+    ))
+
+
+# Backward compatibility
+def load_agent_from_file(agent_path: str, agent_class_name: Optional[str] = None, suppress_output: bool = False) -> 'AgentBase':
+    """
+    Backward compatibility wrapper
+    
+    Note: This still uses the direct extraction approach for compatibility
+    """
+    # Use the new service capture but ensure we get an AgentBase
+    capturer = ServiceCapture()
+    services = capturer.capture(agent_path, suppress_output=suppress_output)
+    
+    # Filter to only agents
+    agents = [s for s in services if isinstance(s, AgentBase)]
+    
+    if not agents:
+        raise ValueError(f"No agents found in {agent_path}")
+    
+    if len(agents) == 1:
+        return agents[0]
+    
+    # Multiple agents - try to match by class name
+    if agent_class_name:
+        for agent in agents:
+            if agent.__class__.__name__ == agent_class_name:
+                return agent
+    
+    # Return first agent
+    return agents[0]
+
+
+def discover_agents_in_file(agent_path: str) -> List[Dict[str, Any]]:
+    """
+    Backward compatibility wrapper
+    """
+    capturer = ServiceCapture()
+    services = capturer.capture(agent_path)
+    
+    # Convert to old format
+    agents_found = []
+    for service in services:
+        if isinstance(service, AgentBase):
+            agents_found.append({
+                'name': service.name,
+                'class_name': service.__class__.__name__,
+                'type': 'instance',
+                'agent_name': service.name,
+                'route': service.route,
+                'description': service.__class__.__doc__,
+                'object': service
+            })
+    
+    return agents_found

signalwire_agents/cli/output/output_formatter.py

@@ -61,7 +61,58 @@ def display_agent_tools(agent: 'AgentBase', verbose: bool = False) -> None:
                             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}")
+                            
+                            # Build constraint details
+                            constraints = []
+                            
+                            # Enum values
+                            if 'enum' in param_def:
+                                constraints.append(f"options: {', '.join(map(str, param_def['enum']))}")
+                            
+                            # Numeric constraints
+                            if 'minimum' in param_def:
+                                constraints.append(f"min: {param_def['minimum']}")
+                            if 'maximum' in param_def:
+                                constraints.append(f"max: {param_def['maximum']}")
+                            if 'exclusiveMinimum' in param_def:
+                                constraints.append(f"min (exclusive): {param_def['exclusiveMinimum']}")
+                            if 'exclusiveMaximum' in param_def:
+                                constraints.append(f"max (exclusive): {param_def['exclusiveMaximum']}")
+                            if 'multipleOf' in param_def:
+                                constraints.append(f"multiple of: {param_def['multipleOf']}")
+                            
+                            # String constraints
+                            if 'minLength' in param_def:
+                                constraints.append(f"min length: {param_def['minLength']}")
+                            if 'maxLength' in param_def:
+                                constraints.append(f"max length: {param_def['maxLength']}")
+                            if 'pattern' in param_def:
+                                constraints.append(f"pattern: {param_def['pattern']}")
+                            if 'format' in param_def:
+                                constraints.append(f"format: {param_def['format']}")
+                            
+                            # Array constraints
+                            if param_type == 'array':
+                                if 'minItems' in param_def:
+                                    constraints.append(f"min items: {param_def['minItems']}")
+                                if 'maxItems' in param_def:
+                                    constraints.append(f"max items: {param_def['maxItems']}")
+                                if 'uniqueItems' in param_def and param_def['uniqueItems']:
+                                    constraints.append("unique items")
+                                if 'items' in param_def and 'type' in param_def['items']:
+                                    constraints.append(f"item type: {param_def['items']['type']}")
+                            
+                            # Default value
+                            if 'default' in param_def:
+                                constraints.append(f"default: {param_def['default']}")
+                            
+                            # Format the type with constraints
+                            if constraints:
+                                param_type_full = f"{param_type} [{', '.join(constraints)}]"
+                            else:
+                                param_type_full = param_type
+                            
+                            print(f"      {param_name} ({param_type_full}){required_marker}: {param_desc}")
                     else:
                         print(f"    Parameters: None")
                 else:
@@ -103,7 +154,58 @@ def display_agent_tools(agent: 'AgentBase', verbose: bool = False) -> None:
                             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}")
+                            
+                            # Build constraint details
+                            constraints = []
+                            
+                            # Enum values
+                            if 'enum' in param_def:
+                                constraints.append(f"options: {', '.join(map(str, param_def['enum']))}")
+                            
+                            # Numeric constraints
+                            if 'minimum' in param_def:
+                                constraints.append(f"min: {param_def['minimum']}")
+                            if 'maximum' in param_def:
+                                constraints.append(f"max: {param_def['maximum']}")
+                            if 'exclusiveMinimum' in param_def:
+                                constraints.append(f"min (exclusive): {param_def['exclusiveMinimum']}")
+                            if 'exclusiveMaximum' in param_def:
+                                constraints.append(f"max (exclusive): {param_def['exclusiveMaximum']}")
+                            if 'multipleOf' in param_def:
+                                constraints.append(f"multiple of: {param_def['multipleOf']}")
+                            
+                            # String constraints
+                            if 'minLength' in param_def:
+                                constraints.append(f"min length: {param_def['minLength']}")
+                            if 'maxLength' in param_def:
+                                constraints.append(f"max length: {param_def['maxLength']}")
+                            if 'pattern' in param_def:
+                                constraints.append(f"pattern: {param_def['pattern']}")
+                            if 'format' in param_def:
+                                constraints.append(f"format: {param_def['format']}")
+                            
+                            # Array constraints
+                            if param_type == 'array':
+                                if 'minItems' in param_def:
+                                    constraints.append(f"min items: {param_def['minItems']}")
+                                if 'maxItems' in param_def:
+                                    constraints.append(f"max items: {param_def['maxItems']}")
+                                if 'uniqueItems' in param_def and param_def['uniqueItems']:
+                                    constraints.append("unique items")
+                                if 'items' in param_def and 'type' in param_def['items']:
+                                    constraints.append(f"item type: {param_def['items']['type']}")
+                            
+                            # Default value
+                            if 'default' in param_def:
+                                constraints.append(f"default: {param_def['default']}")
+                            
+                            # Format the type with constraints
+                            if constraints:
+                                param_type_full = f"{param_type} [{', '.join(constraints)}]"
+                            else:
+                                param_type_full = param_type
+                            
+                            print(f"      {param_name} ({param_type_full}){required_marker}: {param_desc}")
                     else:
                         print(f"    Parameters: None")
                 else:

signalwire_agents/cli/output/swml_dump.py

@@ -30,17 +30,22 @@ if TYPE_CHECKING:
 original_print = print
 
 
-def setup_raw_mode_suppression():
-    """Set up output suppression for raw mode using central logging system"""
+def setup_output_suppression():
+    """Set up output suppression for SWML dumping"""
     # The central logging system is already configured via environment variable
     # Just suppress any remaining warnings
     warnings.filterwarnings("ignore")
     
-    # Capture and suppress print statements in raw mode if needed
+    # Capture and suppress print statements
     def suppressed_print(*args, **kwargs):
-        pass
+        # If file is specified (like stderr), allow it
+        if 'file' in kwargs and kwargs['file'] is not sys.stdout:
+            original_print(*args, **kwargs)
+        else:
+            # Suppress stdout prints
+            pass
     
-    # Replace print function globally for raw mode
+    # Replace print function globally
     import builtins
     builtins.print = suppressed_print
 
@@ -153,21 +158,16 @@ def handle_dump_swml(agent: 'AgentBase', args: argparse.Namespace) -> int:
             swml_doc = agent._render_swml()
         
         if args.raw:
-            # Temporarily restore print for JSON output
-            if '--raw' in sys.argv and 'original_print' in globals():
-                import builtins
-                builtins.print = original_print
-            
             # Output only the raw JSON for piping to jq/yq
-            print(swml_doc)
+            original_print(swml_doc)
         else:
             # Output formatted JSON (like raw but pretty-printed)
             try:
                 swml_parsed = json.loads(swml_doc)
-                print(json.dumps(swml_parsed, indent=2))
+                original_print(json.dumps(swml_parsed, indent=2))
             except json.JSONDecodeError:
                 # If not valid JSON, show raw
-                print(swml_doc)
+                original_print(swml_doc)
         
         return 0
         

signalwire_agents/cli/simulation/mock_env.py

@@ -109,6 +109,8 @@ class MockRequest:
         self.query_params = MockQueryParams(query_params)
         self._json_body = json_body or {}
         self._body = json.dumps(self._json_body).encode('utf-8')
+        # Add state object for request state (used by FastAPI)
+        self.state = type('State', (), {})()
     
     async def json(self) -> Dict[str, Any]:
         """Return the JSON body"""

signalwire_agents/cli/swaig_test_wrapper.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+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.
+"""
+
+"""
+Wrapper script for swaig-test that sets environment variables before importing any modules.
+This allows proper control of logging before the logging system is initialized.
+"""
+
+import os
+import sys
+import subprocess
+
+
+def main():
+    """Main entry point for the swaig-test command"""
+    # Determine if we should show logs based on arguments
+    args = sys.argv[1:]
+    
+    # Check for verbose flag
+    show_logs = '--verbose' in args or '-v' in args
+    
+    # Special cases that always suppress logs
+    force_suppress = '--dump-swml' in args or '--raw' in args
+    
+    # Set logging mode
+    if force_suppress:
+        os.environ['SIGNALWIRE_LOG_MODE'] = 'off'
+    elif show_logs:
+        os.environ['SIGNALWIRE_LOG_MODE'] = 'default'
+    else:
+        # Default: suppress logs unless verbose is requested
+        os.environ['SIGNALWIRE_LOG_MODE'] = 'off'
+    
+    # Execute the actual implementation
+    # Use sys.executable to ensure we use the same Python interpreter
+    # Add -W ignore::RuntimeWarning to suppress the sys.modules warning
+    cmd = [sys.executable, '-W', 'ignore::RuntimeWarning', '-m', 'signalwire_agents.cli.test_swaig'] + args
+    
+    # Run the command and exit with its exit code
+    result = subprocess.run(cmd)
+    sys.exit(result.returncode)
+
+
+if __name__ == '__main__':
+    main()

signalwire_agents/cli/test_swaig.py

@@ -34,7 +34,7 @@ from .config import (
     HELP_DESCRIPTION, HELP_EPILOG_SHORT
 )
 from .core.argparse_helpers import CustomArgumentParser, parse_function_arguments
-from .core.agent_loader import discover_agents_in_file, load_agent_from_file
+from .core.agent_loader import discover_agents_in_file, load_agent_from_file, load_service_from_file
 from .core.dynamic_config import apply_dynamic_config
 from .simulation.mock_env import ServerlessSimulator, create_mock_request, load_env_file
 from .simulation.data_generation import (
@@ -44,7 +44,7 @@ from .simulation.data_generation import (
 from .simulation.data_overrides import apply_overrides, apply_convenience_mappings
 from .execution.datamap_exec import execute_datamap_function
 from .execution.webhook_exec import execute_external_webhook_function
-from .output.swml_dump import handle_dump_swml, setup_raw_mode_suppression
+from .output.swml_dump import handle_dump_swml, setup_output_suppression
 from .output.output_formatter import display_agent_tools, format_result
 
 
@@ -221,9 +221,9 @@ swaig-test agent.py --simulate-serverless cgi --cgi-host example.com --dump-swml
 
 def main():
     """Main entry point for the CLI tool"""
-    # Check for --raw flag and set up suppression early
-    if "--raw" in sys.argv:
-        setup_raw_mode_suppression()
+    # Set up suppression early if we're dumping SWML
+    if "--dump-swml" in sys.argv:
+        setup_output_suppression()
     
     # Check for help sections early
     if "--help-platforms" in sys.argv:
@@ -284,6 +284,10 @@ def main():
         "--agent-class",
         help="Specify agent class (required if file has multiple agents)"
     )
+    common.add_argument(
+        "--route",
+        help="Specify service by route (e.g., /healthcare, /finance)"
+    )
     
     # Actions (choose one)
     actions = parser.add_argument_group('actions (choose one)')
@@ -444,6 +448,9 @@ def main():
         args.tool_name = None
     
     # Validate arguments
+    if args.route and args.agent_class:
+        parser.error("Cannot specify both --route and --agent-class. Choose one.")
+    
     if not args.list_tools and not args.dump_swml and not args.list_agents:
         if not args.tool_name:
             # If no tool_name and no special flags, default to listing tools
@@ -556,7 +563,13 @@ def main():
         
         # Load the agent
         try:
-            agent = load_agent_from_file(args.agent_path, args.agent_class)
+            # Determine which identifier to use
+            service_identifier = args.route if args.route else args.agent_class
+            prefer_route = bool(args.route)
+            
+            # Use load_service_from_file which handles both routes and class names
+            from signalwire_agents.cli.core.agent_loader import load_service_from_file
+            agent = load_service_from_file(args.agent_path, service_identifier, prefer_route)
         except ValueError as e:
             error_msg = str(e)
             if "Multiple agent classes found" in error_msg and args.list_tools and not args.agent_class:
@@ -615,6 +628,7 @@ def main():
                         print("\n" + "=" * 60)
                         print(f"\nTo use a specific agent, run:")
                         print(f"  swaig-test {args.agent_path} --agent-class <AgentClassName>")
+                        print(f"  swaig-test {args.agent_path} --route <route>")
                         return 0
                 except Exception as discover_error:
                     print(f"Error discovering agents: {discover_error}")