signalwire-agents 0.1.13__py3-none-any.whl → 1.0.17.dev4__py3-none-any.whl

signalwire_agents/cli/test_swaig.py

@@ -1,1732 +1,238 @@
 #!/usr/bin/env python3
 """
-SWAIG Function CLI Testing Tool
-
-This tool loads an agent application and calls SWAIG functions with comprehensive
-simulation of the SignalWire environment. It supports both webhook and DataMap functions.
-
-Usage:
-    python -m signalwire_agents.cli.test_swaig <agent_path> <tool_name> <args_json>
-    
-    # Or directly:
-    python signalwire_agents/cli/test_swaig.py <agent_path> <tool_name> <args_json>
-    
-    # Or as installed command:
-    swaig-test <agent_path> <tool_name> <args_json>
-    
-Examples:
-    # Test DataSphere search
-    swaig-test examples/datasphere_webhook_env_demo.py search_knowledge '{"query":"test search"}'
-    
-    # Test DataMap function
-    swaig-test examples/my_agent.py my_datamap_func '{"input":"value"}' --datamap
-    
-    # Test with custom post_data
-    swaig-test examples/my_agent.py my_tool '{"param":"value"}' --fake-full-data
-    
-    # Test with minimal data
-    swaig-test examples/my_agent.py my_tool '{"param":"value"}' --minimal
-    
-    # List available tools
-    swaig-test examples/my_agent.py --list-tools
-    
-    # Dump SWML document
-    swaig-test examples/my_agent.py --dump-swml
-    
-    # Dump SWML with verbose output
-    swaig-test examples/my_agent.py --dump-swml --verbose
-    
-    # Dump raw SWML JSON (for piping to jq/yq)
-    swaig-test examples/my_agent.py --dump-swml --raw
-    
-    # Pipe to jq for pretty formatting
-    swaig-test examples/my_agent.py --dump-swml --raw | jq '.'
-    
-    # Extract specific fields with jq
-    swaig-test examples/my_agent.py --dump-swml --raw | jq '.sections.main[1].ai.SWAIG.functions'
-"""
-
-import sys
-import os
-import json
-import importlib.util
-import argparse
-import uuid
-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
-
-try:
-    # Try to import the AgentBase class
-    from signalwire_agents.core.agent_base import AgentBase
-    from signalwire_agents.core.function_result import SwaigFunctionResult
-except ImportError:
-    # If import fails, we'll handle it gracefully
-    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
-
-
-# ===== MOCK REQUEST OBJECTS FOR DYNAMIC AGENT TESTING =====
-
-class MockQueryParams:
-    """Mock FastAPI QueryParams (case-sensitive dict-like)"""
-    def __init__(self, params: Optional[Dict[str, str]] = None):
-        self._params = params or {}
-    
-    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        return self._params.get(key, default)
-    
-    def __getitem__(self, key: str) -> str:
-        return self._params[key]
-    
-    def __contains__(self, key: str) -> bool:
-        return key in self._params
-    
-    def items(self):
-        return self._params.items()
-    
-    def keys(self):
-        return self._params.keys()
-    
-    def values(self):
-        return self._params.values()
-
-
-class MockHeaders:
-    """Mock FastAPI Headers (case-insensitive dict-like)"""
-    def __init__(self, headers: Optional[Dict[str, str]] = None):
-        # Store headers with lowercase keys for case-insensitive lookup
-        self._headers = {}
-        if headers:
-            for k, v in headers.items():
-                self._headers[k.lower()] = v
-    
-    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
-        return self._headers.get(key.lower(), default)
-    
-    def __getitem__(self, key: str) -> str:
-        return self._headers[key.lower()]
-    
-    def __contains__(self, key: str) -> bool:
-        return key.lower() in self._headers
-    
-    def items(self):
-        return self._headers.items()
-    
-    def keys(self):
-        return self._headers.keys()
-    
-    def values(self):
-        return self._headers.values()
-
-
-class MockURL:
-    """Mock FastAPI URL object"""
-    def __init__(self, url: str = "http://localhost:8080/swml"):
-        self._url = url
-        # Parse basic components
-        if "?" in url:
-            self.path, query_string = url.split("?", 1)
-            self.query = query_string
-        else:
-            self.path = url
-            self.query = ""
-        
-        # Extract scheme and netloc
-        if "://" in url:
-            self.scheme, rest = url.split("://", 1)
-            if "/" in rest:
-                self.netloc = rest.split("/", 1)[0]
-            else:
-                self.netloc = rest
-        else:
-            self.scheme = "http"
-            self.netloc = "localhost:8080"
-    
-    def __str__(self):
-        return self._url
-
-
-class MockRequest:
-    """Mock FastAPI Request object for dynamic agent testing"""
-    def __init__(self, method: str = "POST", url: str = "http://localhost:8080/swml",
-                 headers: Optional[Dict[str, str]] = None,
-                 query_params: Optional[Dict[str, str]] = None,
-                 json_body: Optional[Dict[str, Any]] = None):
-        self.method = method
-        self.url = MockURL(url)
-        self.headers = MockHeaders(headers)
-        self.query_params = MockQueryParams(query_params)
-        self._json_body = json_body or {}
-        self._body = json.dumps(self._json_body).encode('utf-8')
-    
-    async def json(self) -> Dict[str, Any]:
-        """Return the JSON body"""
-        return self._json_body
-    
-    async def body(self) -> bytes:
-        """Return the raw body bytes"""
-        return self._body
-    
-    def client(self):
-        """Mock client property"""
-        return type('MockClient', (), {'host': '127.0.0.1', 'port': 0})()
-
-
-def create_mock_request(method: str = "POST", url: str = "http://localhost:8080/swml",
-                       headers: Optional[Dict[str, str]] = None,
-                       query_params: Optional[Dict[str, str]] = None,
-                       body: Optional[Dict[str, Any]] = None) -> MockRequest:
-    """
-    Factory function to create a mock FastAPI Request object
-    """
-    return MockRequest(method=method, url=url, headers=headers, 
-                      query_params=query_params, json_body=body)
-
-
-# ===== SERVERLESS ENVIRONMENT SIMULATION =====
-
-class ServerlessSimulator:
-    """Manages serverless environment simulation for different platforms"""
-    
-    # Default environment presets for each platform
-    PLATFORM_PRESETS = {
-        'lambda': {
-            'AWS_LAMBDA_FUNCTION_NAME': 'test-agent-function',
-            'AWS_LAMBDA_FUNCTION_URL': 'https://abc123.lambda-url.us-east-1.on.aws/',
-            'AWS_REGION': 'us-east-1',
-            '_HANDLER': 'lambda_function.lambda_handler'
-        },
-        'cgi': {
-            'GATEWAY_INTERFACE': 'CGI/1.1',
-            'HTTP_HOST': 'example.com',
-            'SCRIPT_NAME': '/cgi-bin/agent.cgi',
-            'HTTPS': 'on',
-            'SERVER_NAME': 'example.com'
-        },
-        'cloud_function': {
-            'GOOGLE_CLOUD_PROJECT': 'test-project',
-            'FUNCTION_URL': 'https://my-function-abc123.cloudfunctions.net',
-            'GOOGLE_CLOUD_REGION': 'us-central1',
-            'K_SERVICE': 'agent'
-        },
-        'azure_function': {
-            'AZURE_FUNCTIONS_ENVIRONMENT': 'Development',
-            'FUNCTIONS_WORKER_RUNTIME': 'python',
-            'WEBSITE_SITE_NAME': 'my-function-app'
-        }
-    }
-    
-    def __init__(self, platform: str, overrides: Optional[Dict[str, str]] = None):
-        self.platform = platform
-        self.original_env = dict(os.environ)
-        self.preset_env = self.PLATFORM_PRESETS.get(platform, {}).copy()
-        self.overrides = overrides or {}
-        self.active = False
-        self._cleared_vars = {}
-    
-    def activate(self, verbose: bool = False):
-        """Apply serverless environment simulation"""
-        if self.active:
-            return
-            
-        # Clear conflicting environment variables
-        self._clear_conflicting_env()
-        
-        # Apply preset environment
-        os.environ.update(self.preset_env)
-        
-        # Apply user overrides
-        os.environ.update(self.overrides)
-        
-        # Set appropriate logging mode for serverless simulation
-        if self.platform == 'cgi' and 'SIGNALWIRE_LOG_MODE' not in self.overrides:
-            # CGI mode should default to 'off' unless explicitly overridden
-            os.environ['SIGNALWIRE_LOG_MODE'] = 'off'
-        
-        self.active = True
-        
-        if verbose:
-            print(f"✓ Activated {self.platform} environment simulation")
-            
-            # Debug: Show key environment variables
-            if self.platform == 'lambda':
-                print(f"  AWS_LAMBDA_FUNCTION_NAME: {os.environ.get('AWS_LAMBDA_FUNCTION_NAME')}")
-                print(f"  AWS_LAMBDA_FUNCTION_URL: {os.environ.get('AWS_LAMBDA_FUNCTION_URL')}")
-                print(f"  AWS_REGION: {os.environ.get('AWS_REGION')}")
-            elif self.platform == 'cgi':
-                print(f"  GATEWAY_INTERFACE: {os.environ.get('GATEWAY_INTERFACE')}")
-                print(f"  HTTP_HOST: {os.environ.get('HTTP_HOST')}")
-                print(f"  SCRIPT_NAME: {os.environ.get('SCRIPT_NAME')}")
-                print(f"  SIGNALWIRE_LOG_MODE: {os.environ.get('SIGNALWIRE_LOG_MODE')}")
-            elif self.platform == 'cloud_function':
-                print(f"  GOOGLE_CLOUD_PROJECT: {os.environ.get('GOOGLE_CLOUD_PROJECT')}")
-                print(f"  FUNCTION_URL: {os.environ.get('FUNCTION_URL')}")
-                print(f"  GOOGLE_CLOUD_REGION: {os.environ.get('GOOGLE_CLOUD_REGION')}")
-            elif self.platform == 'azure_function':
-                print(f"  AZURE_FUNCTIONS_ENVIRONMENT: {os.environ.get('AZURE_FUNCTIONS_ENVIRONMENT')}")
-                print(f"  WEBSITE_SITE_NAME: {os.environ.get('WEBSITE_SITE_NAME')}")
-            
-            # Debug: Confirm SWML_PROXY_URL_BASE is cleared
-            proxy_url = os.environ.get('SWML_PROXY_URL_BASE')
-            if proxy_url:
-                print(f"  WARNING: SWML_PROXY_URL_BASE still set: {proxy_url}")
-            else:
-                print(f"  ✓ SWML_PROXY_URL_BASE cleared successfully")
-    
-    def deactivate(self, verbose: bool = False):
-        """Restore original environment"""
-        if not self.active:
-            return
-            
-        os.environ.clear()
-        os.environ.update(self.original_env)
-        self.active = False
-        
-        if verbose:
-            print(f"✓ Deactivated {self.platform} environment simulation")
-    
-    def _clear_conflicting_env(self):
-        """Clear environment variables that might conflict with simulation"""
-        # Remove variables from other platforms
-        conflicting_vars = []
-        for platform, preset in self.PLATFORM_PRESETS.items():
-            if platform != self.platform:
-                conflicting_vars.extend(preset.keys())
-        
-        # Always clear SWML_PROXY_URL_BASE during serverless simulation
-        # so that platform-specific URL generation takes precedence
-        conflicting_vars.append('SWML_PROXY_URL_BASE')
-        
-        for var in conflicting_vars:
-            if var in os.environ:
-                self._cleared_vars[var] = os.environ[var]
-                os.environ.pop(var)
-    
-    def add_override(self, key: str, value: str):
-        """Add an environment variable override"""
-        self.overrides[key] = value
-        if self.active:
-            os.environ[key] = value
-    
-    def get_current_env(self) -> Dict[str, str]:
-        """Get the current environment that would be applied"""
-        env = self.preset_env.copy()
-        env.update(self.overrides)
-        return env
-
-
-def load_env_file(env_file_path: str) -> Dict[str, str]:
-    """Load environment variables from a file"""
-    env_vars = {}
-    if not os.path.exists(env_file_path):
-        raise FileNotFoundError(f"Environment file not found: {env_file_path}")
-    
-    with open(env_file_path, 'r') as f:
-        for line in f:
-            line = line.strip()
-            if line and not line.startswith('#') and '=' in line:
-                key, value = line.split('=', 1)
-                env_vars[key.strip()] = value.strip()
-    
-    return env_vars
-
-
-# ===== FAKE SWML POST DATA GENERATION =====
-
-def generate_fake_uuid() -> str:
-    """Generate a fake UUID for testing"""
-    return str(uuid.uuid4())
-
-
-def generate_fake_node_id() -> str:
-    """Generate a fake node ID for testing"""
-    return f"test-node-{uuid.uuid4().hex[:8]}"
-
-
-def generate_fake_sip_from(call_type: str) -> str:
-    """Generate a fake 'from' address based on call type"""
-    if call_type == "sip":
-        return f"+1555{uuid.uuid4().hex[:7]}"  # Fake phone number
-    else:  # webrtc
-        return f"user-{uuid.uuid4().hex[:8]}@test.domain"
-
-
-def generate_fake_sip_to(call_type: str) -> str:
-    """Generate a fake 'to' address based on call type"""
-    if call_type == "sip":
-        return f"+1444{uuid.uuid4().hex[:7]}"  # Fake phone number
-    else:  # webrtc
-        return f"agent-{uuid.uuid4().hex[:8]}@test.domain"
-
-
-def adapt_for_call_type(call_data: Dict[str, Any], call_type: str) -> Dict[str, Any]:
-    """
-    Adapt call data structure based on call type (sip vs webrtc)
-    
-    Args:
-        call_data: Base call data structure
-        call_type: "sip" or "webrtc"
-        
-    Returns:
-        Adapted call data with appropriate addresses and metadata
-    """
-    call_data = call_data.copy()
-    
-    # Update addresses based on call type
-    call_data["from"] = generate_fake_sip_from(call_type)
-    call_data["to"] = generate_fake_sip_to(call_type)
-    
-    # Add call type specific metadata
-    if call_type == "sip":
-        call_data["type"] = "phone"
-        call_data["headers"] = {
-            "User-Agent": f"Test-SIP-Client/1.0.0",
-            "From": f"<sip:{call_data['from']}@test.sip.provider>",
-            "To": f"<sip:{call_data['to']}@test.sip.provider>",
-            "Call-ID": call_data["call_id"]
-        }
-    else:  # webrtc
-        call_data["type"] = "webrtc"
-        call_data["headers"] = {
-            "User-Agent": "Test-WebRTC-Client/1.0.0",
-            "Origin": "https://test.webrtc.app",
-            "Sec-WebSocket-Protocol": "sip"
-        }
-    
-    return call_data
-
-
-def generate_fake_swml_post_data(call_type: str = "webrtc", 
-                                call_direction: str = "inbound",
-                                call_state: str = "created") -> Dict[str, Any]:
-    """
-    Generate fake SWML post_data that matches real SignalWire structure
-    
-    Args:
-        call_type: "sip" or "webrtc" (default: webrtc)
-        call_direction: "inbound" or "outbound" (default: inbound)
-        call_state: Call state (default: created)
-        
-    Returns:
-        Fake post_data dict with call, vars, and envs structure
-    """
-    call_id = generate_fake_uuid()
-    project_id = generate_fake_uuid()
-    space_id = generate_fake_uuid()
-    current_time = datetime.now().isoformat()
-    
-    # Base call structure
-    call_data = {
-        "call_id": call_id,
-        "node_id": generate_fake_node_id(),
-        "segment_id": generate_fake_uuid(),
-        "call_session_id": generate_fake_uuid(),
-        "tag": call_id,
-        "state": call_state,
-        "direction": call_direction,
-        "type": call_type,
-        "from": generate_fake_sip_from(call_type),
-        "to": generate_fake_sip_to(call_type),
-        "timeout": 30,
-        "max_duration": 14400,
-        "answer_on_bridge": False,
-        "hangup_after_bridge": True,
-        "ringback": [],
-        "record": {},
-        "project_id": project_id,
-        "space_id": space_id,
-        "created_at": current_time,
-        "updated_at": current_time
-    }
-    
-    # Adapt for specific call type
-    call_data = adapt_for_call_type(call_data, call_type)
-    
-    # Complete post_data structure
-    post_data = {
-        "call": call_data,
-        "vars": {
-            "userVariables": {}  # Empty by default, can be filled via overrides
-        },
-        "envs": {}  # Empty by default, can be filled via overrides
-    }
-    
-    return post_data
-
-
-# ===== OVERRIDE SYSTEM =====
-
-def set_nested_value(data: Dict[str, Any], path: str, value: Any) -> None:
-    """
-    Set a nested value using dot notation path
-    
-    Args:
-        data: Dictionary to modify
-        path: Dot-notation path (e.g., "call.call_id" or "vars.userVariables.custom")
-        value: Value to set
-    """
-    keys = path.split('.')
-    current = data
-    
-    # Navigate to the parent of the target key
-    for key in keys[:-1]:
-        if key not in current:
-            current[key] = {}
-        current = current[key]
-    
-    # Set the final value
-    current[keys[-1]] = value
-
-
-def parse_value(value_str: str) -> Any:
-    """
-    Parse a string value into appropriate Python type
-    
-    Args:
-        value_str: String representation of value
-        
-    Returns:
-        Parsed value (str, int, float, bool, None, or JSON object)
-    """
-    # Handle special values
-    if value_str.lower() == 'null':
-        return None
-    elif value_str.lower() == 'true':
-        return True
-    elif value_str.lower() == 'false':
-        return False
-    
-    # Try parsing as number
-    try:
-        if '.' in value_str:
-            return float(value_str)
-        else:
-            return int(value_str)
-    except ValueError:
-        pass
-    
-    # Try parsing as JSON (for objects/arrays)
-    try:
-        return json.loads(value_str)
-    except json.JSONDecodeError:
-        pass
-    
-    # Return as string
-    return value_str
-
-
-def apply_overrides(data: Dict[str, Any], overrides: List[str], 
-                   json_overrides: List[str]) -> Dict[str, Any]:
-    """
-    Apply override values to data using dot notation paths
-    
-    Args:
-        data: Data dictionary to modify
-        overrides: List of "path=value" strings
-        json_overrides: List of "path=json_value" strings
-        
-    Returns:
-        Modified data dictionary
-    """
-    data = data.copy()
-    
-    # Apply simple overrides
-    for override in overrides:
-        if '=' not in override:
-            continue
-        path, value_str = override.split('=', 1)
-        value = parse_value(value_str)
-        set_nested_value(data, path, value)
-    
-    # Apply JSON overrides
-    for json_override in json_overrides:
-        if '=' not in json_override:
-            continue
-        path, json_str = json_override.split('=', 1)
-        try:
-            value = json.loads(json_str)
-            set_nested_value(data, path, value)
-        except json.JSONDecodeError as e:
-            print(f"Warning: Invalid JSON in override '{json_override}': {e}")
-    
-    return data
-
-
-def apply_convenience_mappings(data: Dict[str, Any], args: argparse.Namespace) -> Dict[str, Any]:
-    """
-    Apply convenience CLI arguments to data structure
-    
-    Args:
-        data: Data dictionary to modify
-        args: Parsed CLI arguments
-        
-    Returns:
-        Modified data dictionary
-    """
-    data = data.copy()
-    
-    # Map high-level arguments to specific paths
-    if hasattr(args, 'call_id') and args.call_id:
-        set_nested_value(data, "call.call_id", args.call_id)
-        set_nested_value(data, "call.tag", args.call_id)  # tag often matches call_id
-    
-    if hasattr(args, 'project_id') and args.project_id:
-        set_nested_value(data, "call.project_id", args.project_id)
-    
-    if hasattr(args, 'space_id') and args.space_id:
-        set_nested_value(data, "call.space_id", args.space_id)
-    
-    if hasattr(args, 'call_state') and args.call_state:
-        set_nested_value(data, "call.state", args.call_state)
-    
-    if hasattr(args, 'call_direction') and args.call_direction:
-        set_nested_value(data, "call.direction", args.call_direction)
-    
-    # Handle from/to addresses with fake generation if needed
-    if hasattr(args, 'from_number') and args.from_number:
-        # If looks like phone number, use as-is, otherwise generate fake
-        if args.from_number.startswith('+') or args.from_number.isdigit():
-            set_nested_value(data, "call.from", args.from_number)
-        else:
-            # Generate fake phone number or SIP address
-            call_type = getattr(args, 'call_type', 'webrtc')
-            if call_type == 'sip':
-                set_nested_value(data, "call.from", f"+1555{uuid.uuid4().hex[:7]}")
-            else:
-                set_nested_value(data, "call.from", f"{args.from_number}@test.domain")
-    
-    if hasattr(args, 'to_extension') and args.to_extension:
-        # Similar logic for 'to' address
-        if args.to_extension.startswith('+') or args.to_extension.isdigit():
-            set_nested_value(data, "call.to", args.to_extension)
-        else:
-            call_type = getattr(args, 'call_type', 'webrtc')
-            if call_type == 'sip':
-                set_nested_value(data, "call.to", f"+1444{uuid.uuid4().hex[:7]}")
-            else:
-                set_nested_value(data, "call.to", f"{args.to_extension}@test.domain")
-    
-    # Merge user variables
-    user_vars = {}
-    
-    # Add user_vars if provided
-    if hasattr(args, 'user_vars') and args.user_vars:
-        try:
-            user_vars.update(json.loads(args.user_vars))
-        except json.JSONDecodeError as e:
-            print(f"Warning: Invalid JSON in --user-vars: {e}")
-    
-    # Add query_params if provided (merged into userVariables)
-    if hasattr(args, 'query_params') and args.query_params:
-        try:
-            user_vars.update(json.loads(args.query_params))
-        except json.JSONDecodeError as e:
-            print(f"Warning: Invalid JSON in --query-params: {e}")
-    
-    # Set merged user variables
-    if user_vars:
-        set_nested_value(data, "vars.userVariables", user_vars)
-    
-    return data
-
-
-def handle_dump_swml(agent: 'AgentBase', args: argparse.Namespace) -> int:
-    """
-    Handle SWML dumping with fake post_data and mock request support
-    
-    Args:
-        agent: The loaded agent instance
-        args: Parsed CLI arguments
-        
-    Returns:
-        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}")
-            
-            # Show loaded skills
-            skills = agent.list_skills()
-            if skills:
-                print(f"Skills: {', '.join(skills)}")
-                
-            # Show available functions
-            if hasattr(agent, '_swaig_functions') and agent._swaig_functions:
-                print(f"Functions: {', '.join(agent._swaig_functions.keys())}")
-            
-            print("-" * 60)
-    
-    try:
-        # Generate fake SWML post_data
-        post_data = generate_fake_swml_post_data(
-            call_type=args.call_type,
-            call_direction=args.call_direction,
-            call_state=args.call_state
-        )
-        
-        # Apply convenience mappings from CLI args
-        post_data = apply_convenience_mappings(post_data, args)
-        
-        # Apply explicit overrides
-        post_data = apply_overrides(post_data, args.override, args.override_json)
-        
-        # Parse headers for mock request
-        headers = {}
-        for header in args.header:
-            if '=' in header:
-                key, value = header.split('=', 1)
-                headers[key] = value
-        
-        # Parse query params for mock request (separate from userVariables)
-        query_params = {}
-        if args.query_params:
-            try:
-                query_params = json.loads(args.query_params)
-            except json.JSONDecodeError as e:
-                if not args.raw:
-                    print(f"Warning: Invalid JSON in --query-params: {e}")
-        
-        # Parse request body
-        request_body = {}
-        if args.body:
-            try:
-                request_body = json.loads(args.body)
-            except json.JSONDecodeError as e:
-                if not args.raw:
-                    print(f"Warning: Invalid JSON in --body: {e}")
-        
-        # Create mock request object
-        mock_request = create_mock_request(
-            method=args.method,
-            headers=headers,
-            query_params=query_params,
-            body=request_body
-        )
-        
-        if args.verbose and not args.raw:
-            print(f"Using fake SWML post_data:")
-            print(json.dumps(post_data, indent=2))
-            print(f"\nMock request headers: {dict(mock_request.headers.items())}")
-            print(f"Mock request query params: {dict(mock_request.query_params.items())}")
-            print(f"Mock request method: {mock_request.method}")
-            print("-" * 60)
-        
-        # For dynamic agents, call on_swml_request if available
-        if hasattr(agent, 'on_swml_request'):
-            try:
-                # Dynamic agents expect (request_data, callback_path, request)
-                call_id = post_data.get('call', {}).get('call_id', 'test-call-id')
-                modifications = agent.on_swml_request(post_data, "/swml", mock_request)
-                
-                if args.verbose and not args.raw:
-                    print(f"Dynamic agent modifications: {modifications}")
-                
-                # Generate SWML with modifications
-                swml_doc = agent._render_swml(call_id, modifications)
-            except Exception as e:
-                if args.verbose and not args.raw:
-                    print(f"Dynamic agent callback failed, falling back to static SWML: {e}")
-                # Fall back to static SWML generation
-                swml_doc = agent._render_swml()
-        else:
-            # Static agent - generate SWML normally
-            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)
-        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")
-        
-        return 0
-        
-    except Exception as e:
-        if args.raw:
-            # For raw mode, output error to stderr to not interfere with JSON output
-            original_print(f"Error generating SWML: {e}", file=sys.stderr)
-            if args.verbose:
-                import traceback
-                traceback.print_exc(file=sys.stderr)
-        else:
-            print(f"Error generating SWML: {e}")
-            if args.verbose:
-                import traceback
-                traceback.print_exc()
-        return 1
-
-
-def setup_raw_mode_suppression():
-    """Set up output suppression for raw mode using central logging system"""
-    # 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
-    def suppressed_print(*args, **kwargs):
-        pass
-    
-    # Replace print function globally for raw mode
-    import builtins
-    builtins.print = suppressed_print
-
-
-def generate_comprehensive_post_data(function_name: str, args: Dict[str, Any], 
-                                    custom_data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-    """
-    Generate comprehensive post_data that matches what SignalWire would send
-    
-    Args:
-        function_name: Name of the SWAIG function being called
-        args: Function arguments
-        custom_data: Optional custom data to override defaults
-        
-    Returns:
-        Complete post_data dict with all possible keys
-    """
-    call_id = str(uuid.uuid4())
-    session_id = str(uuid.uuid4())
-    current_time = datetime.now().isoformat()
-    
-    # Generate meta_data_token (normally function name + webhook URL hash)
-    meta_data_token = hashlib.md5(f"{function_name}_test_webhook".encode()).hexdigest()[:16]
-    
-    base_data = {
-        # Core identification 
-        "function": function_name,
-        "argument": args,
-        "call_id": call_id,
-        "call_session_id": session_id,
-        "node_id": "test-node-001",
-        
-        # Metadata and function-level data
-        "meta_data_token": meta_data_token,
-        "meta_data": {
-            "test_mode": True,
-            "function_name": function_name,
-            "last_updated": current_time
-        },
-        
-        # Global application data
-        "global_data": {
-            "app_name": "test_application",
-            "environment": "test",
-            "user_preferences": {"language": "en"},
-            "session_data": {"start_time": current_time}
-        },
-        
-        # Conversation context
-        "call_log": [
-            {
-                "role": "system",
-                "content": "You are a helpful AI assistant created with SignalWire AI Agents."
-            },
-            {
-                "role": "user", 
-                "content": f"Please call the {function_name} function"
-            },
-            {
-                "role": "assistant",
-                "content": f"I'll call the {function_name} function for you.",
-                "tool_calls": [
-                    {
-                        "id": f"call_{call_id[:8]}",
-                        "type": "function",
-                        "function": {
-                            "name": function_name,
-                            "arguments": json.dumps(args)
-                        }
-                    }
-                ]
-            }
-        ],
-        "raw_call_log": [
-            {
-                "role": "system",
-                "content": "You are a helpful AI assistant created with SignalWire AI Agents."
-            },
-            {
-                "role": "user",
-                "content": "Hello"
-            },
-            {
-                "role": "assistant", 
-                "content": "Hello! How can I help you today?"
-            },
-            {
-                "role": "user",
-                "content": f"Please call the {function_name} function"
-            },
-            {
-                "role": "assistant",
-                "content": f"I'll call the {function_name} function for you.",
-                "tool_calls": [
-                    {
-                        "id": f"call_{call_id[:8]}",
-                        "type": "function", 
-                        "function": {
-                            "name": function_name,
-                            "arguments": json.dumps(args)
-                        }
-                    }
-                ]
-            }
-        ],
-        
-        # SWML and prompt variables
-        "prompt_vars": {
-            # From SWML prompt variables
-            "ai_instructions": "You are a helpful assistant",
-            "temperature": 0.7,
-            "max_tokens": 1000,
-            # From global_data 
-            "app_name": "test_application",
-            "environment": "test",
-            "user_preferences": {"language": "en"},
-            "session_data": {"start_time": current_time},
-            # SWML system variables
-            "current_timestamp": current_time,
-            "call_duration": "00:02:15",
-            "caller_number": "+15551234567",
-            "to_number": "+15559876543"
-        },
-        
-        # Permission flags (from SWML parameters)
-        "swaig_allow_swml": True,
-        "swaig_post_conversation": True, 
-        "swaig_post_swml_vars": True,
-        
-        # Additional context
-        "http_method": "POST",
-        "webhook_url": f"https://test.example.com/webhook/{function_name}",
-        "user_agent": "SignalWire-AI-Agent/1.0",
-        "request_headers": {
-            "Content-Type": "application/json",
-            "User-Agent": "SignalWire-AI-Agent/1.0",
-            "X-Signalwire-Call-Id": call_id,
-            "X-Signalwire-Session-Id": session_id
-        }
-    }
-    
-    # Merge custom data if provided
-    if custom_data:
-        def deep_merge(base: Dict, custom: Dict) -> Dict:
-            result = base.copy()
-            for key, value in custom.items():
-                if key in result and isinstance(result[key], dict) and isinstance(value, dict):
-                    result[key] = deep_merge(result[key], value)
-                else:
-                    result[key] = value
-            return result
-        
-        base_data = deep_merge(base_data, custom_data)
-    
-    return base_data
-
-
-def generate_minimal_post_data(function_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
-    """Generate minimal post_data with only essential keys"""
-    return {
-        "function": function_name,
-        "argument": args,
-        "call_id": str(uuid.uuid4()),
-        "meta_data": {},
-        "global_data": {}
-    }
-
-
-def simple_template_expand(template: str, data: Dict[str, Any]) -> str:
-    """
-    Simple template expansion for DataMap testing
-    Supports both ${key} and %{key} syntax with nested object access and array indexing
-    
-    Args:
-        template: Template string with ${} or %{} variables
-        data: Data dictionary for expansion
-        
-    Returns:
-        Expanded string
-    """
-    if not template:
-        return ""
-        
-    result = template
-    
-    # Handle both ${variable.path} and %{variable.path} syntax
-    patterns = [
-        r'\$\{([^}]+)\}',  # ${variable} syntax
-        r'%\{([^}]+)\}'    # %{variable} syntax
-    ]
-    
-    for pattern in patterns:
-        for match in re.finditer(pattern, result):
-            var_path = match.group(1)
-            
-            # Handle array indexing syntax like "array[0].joke"
-            if '[' in var_path and ']' in var_path:
-                # Split path with array indexing
-                parts = []
-                current_part = ""
-                i = 0
-                while i < len(var_path):
-                    if var_path[i] == '[':
-                        if current_part:
-                            parts.append(current_part)
-                            current_part = ""
-                        # Find the closing bracket
-                        j = i + 1
-                        while j < len(var_path) and var_path[j] != ']':
-                            j += 1
-                        if j < len(var_path):
-                            index = var_path[i+1:j]
-                            parts.append(f"[{index}]")
-                            i = j + 1
-                            if i < len(var_path) and var_path[i] == '.':
-                                i += 1  # Skip the dot after ]
-                        else:
-                            current_part += var_path[i]
-                            i += 1
-                    elif var_path[i] == '.':
-                        if current_part:
-                            parts.append(current_part)
-                            current_part = ""
-                        i += 1
-                    else:
-                        current_part += var_path[i]
-                        i += 1
-                
-                if current_part:
-                    parts.append(current_part)
-                    
-                # Navigate through the data structure
-                value = data
-                try:
-                    for part in parts:
-                        if part.startswith('[') and part.endswith(']'):
-                            # Array index
-                            index = int(part[1:-1])
-                            if isinstance(value, list) and 0 <= index < len(value):
-                                value = value[index]
-                            else:
-                                value = f"<MISSING:{var_path}>"
-                                break
-                        else:
-                            # Object property
-                            if isinstance(value, dict) and part in value:
-                                value = value[part]
-                            else:
-                                value = f"<MISSING:{var_path}>"
-                                break
-                except (ValueError, TypeError, IndexError):
-                    value = f"<MISSING:{var_path}>"
-                    
-            else:
-                # Regular nested object access (no array indexing)
-                path_parts = var_path.split('.')
-                value = data
-                for part in path_parts:
-                    if isinstance(value, dict) and part in value:
-                        value = value[part]
-                    else:
-                        value = f"<MISSING:{var_path}>"
-                        break
-            
-            # Replace the variable with its value
-            result = result.replace(match.group(0), str(value))
-    
-    return result
-
-
-def execute_datamap_function(datamap_config: Dict[str, Any], args: Dict[str, Any], 
-                           verbose: bool = False) -> Dict[str, Any]:
-    """
-    Execute a DataMap function by processing its configuration and making HTTP requests
-    
-    Args:
-        datamap_config: The complete DataMap function configuration
-        args: Function arguments
-        verbose: Whether to show verbose output
-        
-    Returns:
-        Final function result
-    """
-    # Extract data_map configuration
-    data_map = datamap_config.get('data_map', {})
-    
-    # Check if this is a simple DataMap (webhooks directly) or complex (with expressions)
-    if 'webhooks' in data_map and 'expressions' not in data_map:
-        # Simple DataMap structure - webhooks directly under data_map
-        webhooks = data_map.get('webhooks', [])
-        fallback_output = data_map.get('output', 'Function completed')
-        if verbose:
-            print(f"Simple DataMap structure with {len(webhooks)} webhook(s)")
-    else:
-        # Complex DataMap structure - with expressions containing webhooks
-        expressions = data_map.get('expressions', [])
-        matched_expression = None
-        
-        if verbose:
-            print(f"Complex DataMap structure with {len(expressions)} expression(s)...")
-        
-        for expr in expressions:
-            pattern = expr.get('pattern', '.*')  # Default to match everything
-            string_value = expr.get('string', '')
-            
-            # Create a test string from the arguments
-            test_string = json.dumps(args)
-            
-            if verbose:
-                print(f"  Testing pattern '{pattern}' against '{test_string}'")
-            
-            # Use regex to match
-            try:
-                if re.search(pattern, test_string):
-                    matched_expression = expr
-                    if verbose:
-                        print(f"  ✓ Pattern matched!")
-                    break
-                elif re.search(pattern, string_value):
-                    matched_expression = expr
-                    if verbose:
-                        print(f"  ✓ Pattern matched against string value!")
-                    break
-            except re.error as e:
-                if verbose:
-                    print(f"  ✗ Invalid regex pattern: {e}")
-        
-        if not matched_expression:
-            if verbose:
-                print("  No expressions matched, using first expression if available")
-            matched_expression = expressions[0] if expressions else {}
-        
-        # Get webhooks from matched expression
-        webhooks = matched_expression.get('webhooks', [])
-        fallback_output = matched_expression.get('output', 'Function completed')
-    webhook_result = None
-    
-    if verbose:
-        print(f"Processing {len(webhooks)} webhook(s)...")
-    
-    for i, webhook in enumerate(webhooks):
-        url = webhook.get('url', '')
-        method = webhook.get('method', 'POST').upper()
-        headers = webhook.get('headers', {})
-        
-        if verbose:
-            print(f"  Webhook {i+1}: {method} {url}")
-        
-        # Prepare request data
-        request_data = args.copy()
-        
-        # Expand URL template with arguments
-        template_context = {"args": args, "array": [], **args}
-        expanded_url = simple_template_expand(url, template_context)
-        
-        if verbose:
-            print(f"    Original URL: {url}")
-            print(f"    Template context: {template_context}")
-            print(f"    Expanded URL: {expanded_url}")
-        
-        try:
-            if method == 'GET':
-                response = requests.get(expanded_url, params=request_data, headers=headers, timeout=10)
-            else:
-                response = requests.post(expanded_url, json=request_data, headers=headers, timeout=10)
-            
-            if response.status_code == 200:
-                try:
-                    webhook_data = response.json()
-                    if verbose:
-                        print(f"  ✓ Webhook succeeded: {response.status_code}")
-                        print(f"    Response: {json.dumps(webhook_data, indent=4)}")
-                    
-                    # Process output template if defined in this webhook
-                    webhook_output = webhook.get('output')
-                    if webhook_output:
-                        # Create context for template expansion
-                        template_context = {
-                            "args": args,
-                            "array": webhook_data if isinstance(webhook_data, list) else [webhook_data]
-                        }
-                        
-                        # Add webhook_data contents to context if it's a dict
-                        if isinstance(webhook_data, dict):
-                            template_context.update(webhook_data)
-                        
-                        if isinstance(webhook_output, dict):
-                            # Process dict output template (e.g., {"response": "template", "action": [...]} )
-                            webhook_result = {}
-                            for key, template in webhook_output.items():
-                                if isinstance(template, str):
-                                    webhook_result[key] = simple_template_expand(template, template_context)
-                                else:
-                                    webhook_result[key] = template
-                        elif isinstance(webhook_output, str):
-                            # Simple string template
-                            webhook_result = {"response": simple_template_expand(webhook_output, template_context)}
-                        else:
-                            # Other types
-                            webhook_result = {"response": str(webhook_output)}
-                        
-                        if verbose:
-                            print(f"    Processed output: {webhook_result}")
-                    else:
-                        webhook_result = webhook_data if isinstance(webhook_data, dict) else {"response": str(webhook_data)}
-                    
-                    break
-                except json.JSONDecodeError:
-                    webhook_result = {"response": response.text}
-                    if verbose:
-                        print(f"  ✓ Webhook succeeded (text): {response.status_code}")
-                    break
-            else:
-                if verbose:
-                    print(f"  ✗ Webhook failed: {response.status_code}")
-        except requests.RequestException as e:
-            if verbose:
-                print(f"  ✗ Webhook request failed: {e}")
-    
-    # If no webhook succeeded, use fallback
-    if webhook_result is None:
-        if verbose:
-            print("All webhooks failed, using fallback output...")
-        
-        # Use the fallback output determined earlier
-        output_template = fallback_output
-        
-        # Handle both string and dict output templates
-        if isinstance(output_template, dict):
-            # Process dict output template (e.g., {"response": "template"})
-            webhook_result = {}
-            for key, template in output_template.items():
-                if isinstance(template, str):
-                    webhook_result[key] = simple_template_expand(template, {"args": args})
-                else:
-                    webhook_result[key] = template
-        elif isinstance(output_template, str):
-            # Simple string template
-            webhook_result = {"response": simple_template_expand(output_template, {"args": args})}
-        else:
-            # Other types (shouldn't happen but be safe)
-            webhook_result = {"response": str(output_template)}
-        
-        if verbose:
-            print(f"Fallback result = {webhook_result}")
-    
-    # Process foreach (not implemented in this simple version)
-    # This would iterate over array results and apply templates
-    
-    return webhook_result
-
-
-def execute_external_webhook_function(func: 'SWAIGFunction', function_name: str, function_args: Dict[str, Any], 
-                                    post_data: Dict[str, Any], verbose: bool = False) -> Dict[str, Any]:
-    """
-    Execute an external webhook SWAIG function by making an HTTP request to the external service.
-    This simulates what SignalWire would do when calling an external webhook function.
-    
-    Args:
-        func: The SWAIGFunction object with webhook_url
-        function_name: Name of the function being called
-        function_args: Parsed function arguments
-        post_data: Complete post data to send to the webhook
-        verbose: Whether to show verbose output
-        
-    Returns:
-        Response from the external webhook service
-    """
-    webhook_url = func.webhook_url
-    
-    if verbose:
-        print(f"\nCalling EXTERNAL webhook: {function_name}")
-        print(f"URL: {webhook_url}")
-        print(f"Arguments: {json.dumps(function_args, indent=2)}")
-        print("-" * 60)
-    
-    # Prepare the SWAIG function call payload that SignalWire would send
-    swaig_payload = {
-        "function": function_name,
-        "argument": {
-            "parsed": [function_args] if function_args else [{}],
-            "raw": json.dumps(function_args) if function_args else "{}"
-        }
-    }
-    
-    # Add call_id and other data from post_data if available
-    if "call_id" in post_data:
-        swaig_payload["call_id"] = post_data["call_id"]
-    
-    # Add any other relevant fields from post_data
-    for key in ["call", "device", "vars"]:
-        if key in post_data:
-            swaig_payload[key] = post_data[key]
-    
-    if verbose:
-        print(f"Sending payload: {json.dumps(swaig_payload, indent=2)}")
-        print(f"Making POST request to: {webhook_url}")
-    
-    try:
-        # Make the HTTP request to the external webhook
-        headers = {
-            "Content-Type": "application/json",
-            "User-Agent": "SignalWire-SWAIG-Test/1.0"
-        }
-        
-        response = requests.post(
-            webhook_url,
-            json=swaig_payload,
-            headers=headers,
-            timeout=30  # 30 second timeout
-        )
-        
-        if verbose:
-            print(f"Response status: {response.status_code}")
-            print(f"Response headers: {dict(response.headers)}")
-        
-        if response.status_code == 200:
-            try:
-                result = response.json()
-                if verbose:
-                    print(f"✓ External webhook succeeded")
-                    print(f"Response: {json.dumps(result, indent=2)}")
-                return result
-            except json.JSONDecodeError:
-                # If response is not JSON, wrap it in a response field
-                result = {"response": response.text}
-                if verbose:
-                    print(f"✓ External webhook succeeded (text response)")
-                    print(f"Response: {response.text}")
-                return result
-        else:
-            error_msg = f"External webhook returned HTTP {response.status_code}"
-            if verbose:
-                print(f"✗ External webhook failed: {error_msg}")
-                try:
-                    error_detail = response.json()
-                    print(f"Error details: {json.dumps(error_detail, indent=2)}")
-                except:
-                    print(f"Error response: {response.text}")
-            
-            return {
-                "error": error_msg,
-                "status_code": response.status_code,
-                "response": response.text
-            }
-    
-    except requests.Timeout:
-        error_msg = f"External webhook timed out after 30 seconds"
-        if verbose:
-            print(f"✗ {error_msg}")
-        return {"error": error_msg}
-    
-    except requests.ConnectionError as e:
-        error_msg = f"Could not connect to external webhook: {e}"
-        if verbose:
-            print(f"✗ {error_msg}")
-        return {"error": error_msg}
-    
-    except requests.RequestException as e:
-        error_msg = f"Request to external webhook failed: {e}"
-        if verbose:
-            print(f"✗ {error_msg}")
-        return {"error": error_msg}
-
-
-def discover_agents_in_file(agent_path: str) -> List[Dict[str, Any]]:
-    """
-    Discover all available agents in a Python file without instantiating them
-    
-    Args:
-        agent_path: Path to the Python file containing agents
-        
-    Returns:
-        List of dictionaries with agent information
-        
-    Raises:
-        ImportError: If the file cannot be imported
-        FileNotFoundError: If the file doesn't exist
-    """
-    agent_path = Path(agent_path).resolve()
-    
-    if not agent_path.exists():
-        raise FileNotFoundError(f"Agent file not found: {agent_path}")
-    
-    if not agent_path.suffix == '.py':
-        raise ValueError(f"Agent file must be a Python file (.py): {agent_path}")
-    
-    # Load the module, but prevent main() execution by setting __name__ to something other than "__main__"
-    spec = importlib.util.spec_from_file_location("agent_module", agent_path)
-    module = importlib.util.module_from_spec(spec)
-    
-    try:
-        # Set __name__ to prevent if __name__ == "__main__": blocks from running
-        module.__name__ = "agent_module"
-        spec.loader.exec_module(module)
-    except Exception as e:
-        raise ImportError(f"Failed to load agent module: {e}")
-    
-    agents_found = []
-    
-    # Look for AgentBase instances
-    for name, obj in vars(module).items():
-        if isinstance(obj, AgentBase):
-            agents_found.append({
-                'name': name,
-                'class_name': obj.__class__.__name__,
-                'type': 'instance',
-                'agent_name': getattr(obj, 'name', 'Unknown'),
-                'route': getattr(obj, 'route', 'Unknown'),
-                'description': obj.__class__.__doc__,
-                'object': obj
-            })
-    
-    # Look for AgentBase subclasses (that could be instantiated)
-    for name, obj in vars(module).items():
-        if (isinstance(obj, type) and 
-            issubclass(obj, AgentBase) and 
-            obj != AgentBase):
-            # Check if we already found an instance of this class
-            instance_found = any(agent['class_name'] == name for agent in agents_found)
-            if not instance_found:
-                try:
-                    # Try to get class information without instantiating
-                    agent_info = {
-                        'name': name,
-                        'class_name': name,
-                        'type': 'class',
-                        'agent_name': 'Unknown (not instantiated)',
-                        'route': 'Unknown (not instantiated)',
-                        'description': obj.__doc__,
-                        'object': obj
-                    }
-                    agents_found.append(agent_info)
-                except Exception:
-                    # If we can't get info, still record that the class exists
-                    agents_found.append({
-                        'name': name,
-                        'class_name': name,
-                        'type': 'class',
-                        'agent_name': 'Unknown (not instantiated)',
-                        'route': 'Unknown (not instantiated)',
-                        'description': obj.__doc__ or 'No description available',
-                        'object': obj
-                    })
-    
-    return agents_found
-
-
-def load_agent_from_file(agent_path: str, agent_class_name: Optional[str] = None) -> 'AgentBase':
-    """
-    Load an agent from a Python file
-    
-    Args:
-        agent_path: Path to the Python file containing the agent
-        agent_class_name: Optional name of the agent class to instantiate
-        
-    Returns:
-        AgentBase instance
-        
-    Raises:
-        ImportError: If the file cannot be imported
-        ValueError: If no agent is found in the file
-    """
-    agent_path = Path(agent_path).resolve()
-    
-    if not agent_path.exists():
-        raise FileNotFoundError(f"Agent file not found: {agent_path}")
-    
-    if not agent_path.suffix == '.py':
-        raise ValueError(f"Agent file must be a Python file (.py): {agent_path}")
-    
-    # Load the module, but prevent main() execution by setting __name__ to something other than "__main__"
-    spec = importlib.util.spec_from_file_location("agent_module", agent_path)
-    module = importlib.util.module_from_spec(spec)
-    
-    try:
-        # Set __name__ to prevent if __name__ == "__main__": blocks from running
-        module.__name__ = "agent_module"
-        spec.loader.exec_module(module)
-    except Exception as e:
-        raise ImportError(f"Failed to load agent module: {e}")
-    
-    # Find the agent instance
-    agent = None
-    
-    # If agent_class_name is specified, try to instantiate that specific class first
-    if agent_class_name:
-        if hasattr(module, agent_class_name):
-            obj = getattr(module, agent_class_name)
-            if isinstance(obj, type) and issubclass(obj, AgentBase) and obj != AgentBase:
-                try:
-                    agent = obj()
-                    if agent and not agent.route.endswith('dummy'):  # Avoid test agents with dummy routes
-                        pass  # Successfully created specific agent
-                    else:
-                        agent = obj()  # Create anyway if requested specifically
-                except Exception as e:
-                    raise ValueError(f"Failed to instantiate agent class '{agent_class_name}': {e}")
-            else:
-                raise ValueError(f"'{agent_class_name}' is not a valid AgentBase subclass")
-        else:
-            raise ValueError(f"Agent class '{agent_class_name}' not found in {agent_path}")
-    
-    # Strategy 1: Look for 'agent' variable (most common pattern)
-    if agent is None and hasattr(module, 'agent') and isinstance(module.agent, AgentBase):
-        agent = module.agent
-    
-    # Strategy 2: Look for any AgentBase instance in module globals
-    if agent is None:
-        agents_found = []
-        for name, obj in vars(module).items():
-            if isinstance(obj, AgentBase):
-                agents_found.append((name, obj))
-        
-        if len(agents_found) == 1:
-            agent = agents_found[0][1]
-        elif len(agents_found) > 1:
-            # Multiple agents found, prefer one named 'agent'
-            for name, obj in agents_found:
-                if name == 'agent':
-                    agent = obj
-                    break
-            # If no 'agent' variable, use the first one
-            if agent is None:
-                agent = agents_found[0][1]
-                print(f"Warning: Multiple agents found, using '{agents_found[0][0]}'")
-                print(f"Hint: Use --agent-class parameter to choose specific agent")
-    
-    # Strategy 3: Look for AgentBase subclass and try to instantiate it
-    if agent is None:
-        agent_classes_found = []
-        for name, obj in vars(module).items():
-            if (isinstance(obj, type) and 
-                issubclass(obj, AgentBase) and 
-                obj != AgentBase):
-                agent_classes_found.append((name, obj))
-        
-        if len(agent_classes_found) == 1:
-            try:
-                agent = agent_classes_found[0][1]()
-            except Exception as e:
-                print(f"Warning: Failed to instantiate {agent_classes_found[0][0]}: {e}")
-        elif len(agent_classes_found) > 1:
-            # Multiple agent classes found
-            class_names = [name for name, _ in agent_classes_found]
-            raise ValueError(f"Multiple agent classes found: {', '.join(class_names)}. "
-                           f"Please specify which agent class to use with --agent-class parameter. "
-                           f"Usage: swaig-test {agent_path} [tool_name] [args] --agent-class <AgentClassName>")
-        else:
-            # Try instantiating any AgentBase class we can find
-            for name, obj in vars(module).items():
-                if (isinstance(obj, type) and 
-                    issubclass(obj, AgentBase) and 
-                    obj != AgentBase):
-                    try:
-                        agent = obj()
-                        break
-                    except Exception as e:
-                        print(f"Warning: Failed to instantiate {name}: {e}")
-    
-    # Strategy 4: Try calling a modified main() function that doesn't start the server
-    if agent is None and hasattr(module, 'main'):
-        print("Warning: No agent instance found, attempting to call main() without server startup")
-        try:
-            # Temporarily patch AgentBase.serve to prevent server startup
-            original_serve = AgentBase.serve
-            captured_agent = []
-            
-            def mock_serve(self, *args, **kwargs):
-                captured_agent.append(self)
-                print(f"  (Intercepted serve() call, agent captured for testing)")
-                return self
-            
-            AgentBase.serve = mock_serve
-            
-            try:
-                result = module.main()
-                if isinstance(result, AgentBase):
-                    agent = result
-                elif captured_agent:
-                    agent = captured_agent[0]
-            finally:
-                # Restore original serve method
-                AgentBase.serve = original_serve
-                
-        except Exception as e:
-            print(f"Warning: Failed to call main() function: {e}")
-    
-    if agent is None:
-        raise ValueError(f"No AgentBase instance found in {agent_path}. "
-                        f"Make sure the file contains an agent variable or AgentBase subclass.")
-    
-    return agent
-
-
-def format_result(result: Any) -> str:
-    """
-    Format the result of a SWAIG function call for display
-    
-    Args:
-        result: The result from the SWAIG function
-        
-    Returns:
-        Formatted string representation
-    """
-    if isinstance(result, SwaigFunctionResult):
-        return f"SwaigFunctionResult: {result.response}"
-    elif isinstance(result, dict):
-        if 'response' in result:
-            return f"Response: {result['response']}"
-        else:
-            return f"Dict: {json.dumps(result, indent=2)}"
-    elif isinstance(result, str):
-        return f"String: {result}"
-    else:
-        return f"Other ({type(result).__name__}): {result}"
-
-
-def parse_function_arguments(function_args_list: List[str], func_schema: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Parse function arguments from command line with type coercion based on schema
-    
-    Args:
-        function_args_list: List of command line arguments after --args
-        func_schema: Function schema with parameter definitions
-        
-    Returns:
-        Dictionary of parsed function arguments
-    """
-    parsed_args = {}
-    i = 0
-    
-    # Get parameter schema
-    parameters = {}
-    required_params = []
-    
-    if isinstance(func_schema, dict):
-        # DataMap function
-        if 'parameters' in func_schema:
-            params = func_schema['parameters']
-            if 'properties' in params:
-                parameters = params['properties']
-                required_params = params.get('required', [])
-            else:
-                parameters = params
-        else:
-            parameters = func_schema
-    else:
-        # Regular SWAIG function
-        if hasattr(func_schema, 'parameters') and func_schema.parameters:
-            params = func_schema.parameters
-            if 'properties' in params:
-                parameters = params['properties']
-                required_params = params.get('required', [])
-            else:
-                parameters = params
-    
-    # Parse arguments
-    while i < len(function_args_list):
-        arg = function_args_list[i]
-        
-        if arg.startswith('--'):
-            param_name = arg[2:]  # Remove --
-            
-            # Convert kebab-case to snake_case for parameter lookup
-            param_key = param_name.replace('-', '_')
-            
-            # Check if this parameter exists in schema
-            param_schema = parameters.get(param_key, {})
-            param_type = param_schema.get('type', 'string')
-            
-            if param_type == 'boolean':
-                # Check if next arg is a boolean value or if this is a flag
-                if i + 1 < len(function_args_list) and function_args_list[i + 1].lower() in ['true', 'false']:
-                    parsed_args[param_key] = function_args_list[i + 1].lower() == 'true'
-                    i += 2
-                else:
-                    # Treat as flag (present = true)
-                    parsed_args[param_key] = True
-                    i += 1
-            else:
-                # Need a value
-                if i + 1 >= len(function_args_list):
-                    raise ValueError(f"Parameter --{param_name} requires a value")
-                
-                value = function_args_list[i + 1]
-                
-                # Type coercion
-                if param_type == 'integer':
-                    try:
-                        parsed_args[param_key] = int(value)
-                    except ValueError:
-                        raise ValueError(f"Parameter --{param_name} must be an integer, got: {value}")
-                elif param_type == 'number':
-                    try:
-                        parsed_args[param_key] = float(value)
-                    except ValueError:
-                        raise ValueError(f"Parameter --{param_name} must be a number, got: {value}")
-                elif param_type == 'array':
-                    # Handle comma-separated arrays
-                    parsed_args[param_key] = [item.strip() for item in value.split(',')]
-                else:
-                    # String (default)
-                    parsed_args[param_key] = value
-                
-                i += 2
-        else:
-            raise ValueError(f"Expected parameter name starting with --, got: {arg}")
-    
-    return parsed_args
+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.
+"""
+
+"""
+SWAIG Function CLI Testing Tool
+
+This tool loads an agent application and calls SWAIG functions with comprehensive
+simulation of the SignalWire environment. It supports both webhook and DataMap functions.
+"""
+
+# CRITICAL: Set environment variable BEFORE any imports to suppress logs for --raw and --dump-swml
+import sys
+import os
+if "--raw" in sys.argv or "--dump-swml" in sys.argv:
+    os.environ['SIGNALWIRE_LOG_MODE'] = 'off'
+
+import json
+import argparse
+import warnings
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+# Import submodules
+from .config import (
+    ERROR_MISSING_AGENT, ERROR_MULTIPLE_AGENTS, ERROR_NO_AGENTS,
+    ERROR_AGENT_NOT_FOUND, ERROR_FUNCTION_NOT_FOUND, ERROR_CGI_HOST_REQUIRED,
+    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, 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 (
+    generate_fake_swml_post_data, generate_comprehensive_post_data,
+    generate_minimal_post_data
+)
+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_output_suppression
+from .output.output_formatter import display_agent_tools, format_result
+
+
+def print_help_platforms():
+    """Print detailed help for serverless platform options"""
+    print("""
+Serverless Platform Configuration Options
+========================================
+
+AWS Lambda Configuration:
+  --aws-function-name NAME     AWS Lambda function name (overrides default)
+  --aws-function-url URL       AWS Lambda function URL (overrides default)
+  --aws-region REGION          AWS region (overrides default)
+  --aws-api-gateway-id ID      AWS API Gateway ID for API Gateway URLs
+  --aws-stage STAGE            AWS API Gateway stage (default: prod)
+
+CGI Configuration:
+  --cgi-host HOST              CGI server hostname (required for CGI simulation)
+  --cgi-script-name NAME       CGI script name/path (overrides default)
+  --cgi-https                  Use HTTPS for CGI URLs
+  --cgi-path-info PATH         CGI PATH_INFO value
+
+Google Cloud Platform Configuration:
+  --gcp-project ID             Google Cloud project ID (overrides default)
+  --gcp-function-url URL       Google Cloud Function URL (overrides default)
+  --gcp-region REGION          Google Cloud region (overrides default)
+  --gcp-service NAME           Google Cloud service name (overrides default)
+
+Azure Functions Configuration:
+  --azure-env ENV              Azure Functions environment (overrides default)
+  --azure-function-url URL     Azure Function URL (overrides default)
+
+Examples:
+  # AWS Lambda with custom configuration
+  swaig-test agent.py --simulate-serverless lambda \\
+    --aws-function-name prod-agent \\
+    --aws-region us-west-2 \\
+    --dump-swml
+
+  # CGI with HTTPS
+  swaig-test agent.py --simulate-serverless cgi \\
+    --cgi-host example.com \\
+    --cgi-https \\
+    --exec my_function
+""")
+
+
+def print_help_examples():
+    """Print comprehensive usage examples"""
+    print("""
+Comprehensive Usage Examples
+===========================
+
+Basic Function Testing
+---------------------
+# Test a function with CLI-style arguments
+swaig-test agent.py --exec search --query "AI" --limit 5
+
+# Test with verbose output
+swaig-test agent.py --verbose --exec search --query "test"
+
+# Legacy JSON syntax (still supported)
+swaig-test agent.py search '{"query":"test"}'
+
+SWML Document Generation
+-----------------------
+# Generate basic SWML
+swaig-test agent.py --dump-swml
+
+# Generate SWML with raw JSON output (for piping)
+swaig-test agent.py --dump-swml --raw | jq '.'
+
+# Extract specific fields with jq
+swaig-test agent.py --dump-swml --raw | jq '.sections.main[1].ai.SWAIG.functions'
+
+# Generate SWML with comprehensive fake data
+swaig-test agent.py --dump-swml --fake-full-data
+
+# Customize call configuration
+swaig-test agent.py --dump-swml --call-type sip --from-number +15551234567
+
+Multi-Agent Files
+----------------
+# List available agents
+swaig-test multi_agent.py --list-agents
+
+# Use specific agent
+swaig-test multi_agent.py --agent-class MattiAgent --list-tools
+swaig-test multi_agent.py --agent-class MattiAgent --exec transfer --name sigmond
+
+Dynamic Agent Testing
+--------------------
+# Test with query parameters
+swaig-test dynamic_agent.py --dump-swml --query-params '{"tier":"premium"}'
+
+# Test with headers
+swaig-test dynamic_agent.py --dump-swml --header "Authorization=Bearer token"
+
+# Test with custom request body
+swaig-test dynamic_agent.py --dump-swml --method POST --body '{"custom":"data"}'
+
+# Combined dynamic configuration
+swaig-test dynamic_agent.py --dump-swml \\
+  --query-params '{"tier":"premium","region":"eu"}' \\
+  --header "X-Customer-ID=12345" \\
+  --user-vars '{"preferences":{"language":"es"}}'
+
+Serverless Environment Simulation
+--------------------------------
+# AWS Lambda simulation
+swaig-test agent.py --simulate-serverless lambda --dump-swml
+swaig-test agent.py --simulate-serverless lambda --exec my_function --param value
+
+# With environment variables
+swaig-test agent.py --simulate-serverless lambda \\
+  --env API_KEY=secret \\
+  --env DEBUG=1 \\
+  --exec my_function
+
+# With environment file
+swaig-test agent.py --simulate-serverless lambda \\
+  --env-file production.env \\
+  --exec my_function
+
+# CGI simulation
+swaig-test agent.py --simulate-serverless cgi \\
+  --cgi-host example.com \\
+  --cgi-https \\
+  --exec my_function
+
+# Google Cloud Functions
+swaig-test agent.py --simulate-serverless cloud_function \\
+  --gcp-project my-project \\
+  --exec my_function
+
+# Azure Functions
+swaig-test agent.py --simulate-serverless azure_function \\
+  --azure-env production \\
+  --exec my_function
+
+Advanced Data Overrides
+----------------------
+# Override specific values
+swaig-test agent.py --dump-swml \\
+  --override call.state=answered \\
+  --override call.timeout=60
+
+# Override with JSON values
+swaig-test agent.py --dump-swml \\
+  --override-json vars.custom='{"key":"value","nested":{"data":true}}'
+
+# Combine multiple override types
+swaig-test agent.py --dump-swml \\
+  --call-type sip \\
+  --user-vars '{"vip":"true"}' \\
+  --header "X-Source=test" \\
+  --override call.project_id=my-project \\
+  --verbose
+
+Cross-Platform Testing
+---------------------
+# Test across all platforms
+for platform in lambda cgi cloud_function azure_function; do
+  echo "Testing $platform..."
+  swaig-test agent.py --simulate-serverless $platform \\
+    --exec my_function --param value
+done
+
+# Compare webhook URLs across platforms
+swaig-test agent.py --simulate-serverless lambda --dump-swml | grep web_hook_url
+swaig-test agent.py --simulate-serverless cgi --cgi-host example.com --dump-swml | grep web_hook_url
+""")
 
 
 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:
+        print_help_platforms()
+        sys.exit(0)
+    
+    if "--help-examples" in sys.argv:
+        print_help_examples()
+        sys.exit(0)
     
     # Check for --exec and split arguments  
     cli_args = sys.argv[1:]
@@ -1749,424 +255,185 @@ def main():
     original_argv = sys.argv[:]
     sys.argv = [sys.argv[0]] + cli_args
     
-    # Custom ArgumentParser class with better error handling
-    class CustomArgumentParser(argparse.ArgumentParser):
-        def __init__(self, *args, **kwargs):
-            super().__init__(*args, **kwargs)
-            self._suppress_usage = False
-        
-        def _print_message(self, message, file=None):
-            """Override to suppress usage output for specific errors"""
-            if self._suppress_usage:
-                return
-            super()._print_message(message, file)
-        
-        def error(self, message):
-            """Override error method to provide user-friendly error messages"""
-            if "required" in message.lower() and "agent_path" in message:
-                self._suppress_usage = True
-                print("Error: Missing required argument.")
-                print()
-                print(f"Usage: {self.prog} <agent_path> [options]")
-                print()
-                print("Examples:")
-                print(f"  {self.prog} examples/my_agent.py --list-tools")
-                print(f"  {self.prog} examples/my_agent.py --dump-swml")
-                print(f"  {self.prog} examples/my_agent.py --exec my_function --param value")
-                print()
-                print(f"For full help: {self.prog} --help")
-                sys.exit(2)
-            else:
-                # For other errors, use the default behavior
-                super().error(message)
-        
-        def print_usage(self, file=None):
-            """Override print_usage to suppress output when we want custom error handling"""
-            if self._suppress_usage:
-                return
-            super().print_usage(file)
-        
-        def parse_args(self, args=None, namespace=None):
-            """Override parse_args to provide custom error handling for missing arguments"""
-            # Check if no arguments provided (just the program name)
-            import sys
-            if args is None:
-                args = sys.argv[1:]
-            
-            # If no arguments provided, show custom error
-            if not args:
-                print("Error: Missing required argument.")
-                print()
-                print(f"Usage: {self.prog} <agent_path> [options]")
-                print()
-                print("Examples:")
-                print(f"  {self.prog} examples/my_agent.py --list-tools")
-                print(f"  {self.prog} examples/my_agent.py --dump-swml")
-                print(f"  {self.prog} examples/my_agent.py --exec my_function --param value")
-                print()
-                print(f"For full help: {self.prog} --help")
-                sys.exit(2)
-            
-            # Otherwise, use default parsing
-            return super().parse_args(args, namespace)
-    
     parser = CustomArgumentParser(
-        description="Test SWAIG functions from agent applications with comprehensive simulation",
+        description=HELP_DESCRIPTION,
         formatter_class=argparse.RawDescriptionHelpFormatter,
         usage="%(prog)s <agent_path> [options]",
-        epilog="""
-Examples:
-  # Function testing with --exec syntax  
-  %(prog)s examples/agent.py --verbose --exec search --query "AI" --limit 5
-  %(prog)s examples/web_search_agent.py --exec web_search --query "test"
-  
-  # Legacy JSON syntax (still supported)
-  %(prog)s examples/web_search_agent.py web_search '{"query":"test"}'
-  
-  # Multiple agents - auto-select when only one, or specify with --agent-class  
-  %(prog)s matti_and_sigmond/dual_agent_app.py --agent-class MattiAgent --exec transfer --name sigmond
-  %(prog)s matti_and_sigmond/dual_agent_app.py --verbose --agent-class SigmondAgent --exec get_weather --location "New York"
-  
-  # SWML testing (enhanced with fake post_data)
-  %(prog)s examples/my_agent.py --dump-swml
-  %(prog)s examples/my_agent.py --dump-swml --raw | jq '.'
-  %(prog)s examples/my_agent.py --dump-swml --verbose
-  
-  # SWML testing with specific agent class
-  %(prog)s matti_and_sigmond/dual_agent_app.py --dump-swml --agent-class MattiAgent
-  
-  # SWML testing with call customization
-  %(prog)s examples/agent.py --dump-swml --call-type sip --call-direction outbound
-  %(prog)s examples/agent.py --dump-swml --call-state answered --from-number +15551234567
-  
-  # SWML testing with data overrides
-  %(prog)s examples/agent.py --dump-swml --override call.project_id=my-project
-  %(prog)s examples/agent.py --dump-swml --user-vars '{"customer_id":"12345","tier":"gold"}'
-  %(prog)s examples/agent.py --dump-swml --override call.timeout=60 --override call.state=answered
-  
-  # Dynamic agent testing with mock request
-  %(prog)s examples/dynamic_agent.py --dump-swml --header "Authorization=Bearer token"
-  %(prog)s examples/dynamic_agent.py --dump-swml --query-params '{"source":"api","debug":"true"}'
-  %(prog)s examples/dynamic_agent.py --dump-swml --method GET --body '{"custom":"data"}'
-  
-  # Serverless environment simulation
-  %(prog)s examples/my_agent.py --simulate-serverless lambda --dump-swml
-  %(prog)s examples/my_agent.py --simulate-serverless lambda --exec my_function --param value
-  %(prog)s examples/my_agent.py --simulate-serverless cgi --cgi-host example.com --dump-swml
-  %(prog)s examples/my_agent.py --simulate-serverless cloud_function --gcp-project my-project --exec my_function
-  
-  # Serverless with environment variables
-  %(prog)s examples/my_agent.py --simulate-serverless lambda --env API_KEY=secret --env DEBUG=1 --exec my_function
-  %(prog)s examples/my_agent.py --simulate-serverless lambda --env-file production.env --exec my_function
-  
-  # Platform-specific serverless configuration
-  %(prog)s examples/my_agent.py --simulate-serverless lambda --aws-function-name prod-function --aws-region us-west-2 --dump-swml
-  %(prog)s examples/my_agent.py --simulate-serverless cgi --cgi-host production.com --cgi-https --exec my_function
-  
-  # Combined testing scenarios
-  %(prog)s examples/agent.py --dump-swml --call-type sip --user-vars '{"vip":"true"}' --header "X-Source=test" --verbose
-  %(prog)s examples/agent.py --simulate-serverless lambda --dump-swml --call-type sip --verbose
-  
-  # Discovery commands
-  %(prog)s examples/my_agent.py --list-agents
-  %(prog)s examples/my_agent.py --list-tools
-  %(prog)s matti_and_sigmond/dual_agent_app.py --list-agents
-  %(prog)s matti_and_sigmond/dual_agent_app.py --agent-class MattiAgent --list-tools
-  
-  # Auto-discovery (lists agents when no other args provided)
-  %(prog)s matti_and_sigmond/dual_agent_app.py
-        """
+        epilog=HELP_EPILOG_SHORT
     )
     
-    # Required positional arguments
+    # Positional arguments
     parser.add_argument(
         "agent_path",
-        help="Path to the Python file containing the agent"
-    )
-    
-    parser.add_argument(
-        "tool_name", 
-        nargs="?",
-        help="Name of the SWAIG function/tool to call (optional, can use --exec instead)"
-    )
-    
-    parser.add_argument(
-        "args_json",
-        nargs="?",
-        help="JSON string containing the arguments to pass to the function (when using positional tool_name)"
+        help="Path to Python file containing the agent"
     )
     
-    # Function Execution Options
-    func_group = parser.add_argument_group('Function Execution Options')
-    func_group.add_argument(
-        "--exec",
-        metavar="FUNCTION",
-        help="Execute a function with CLI-style arguments (replaces tool_name and --args)"
+    # Common options
+    common = parser.add_argument_group('common options')
+    common.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose output"
     )
-    
-    func_group.add_argument(
-        "--custom-data",
-        help="Optional JSON string containing custom post_data overrides",
-        default="{}"
+    common.add_argument(
+        "--raw",
+        action="store_true",
+        help="Output raw JSON only (for piping to jq)"
     )
-    
-    # Agent Discovery and Selection
-    agent_group = parser.add_argument_group('Agent Discovery and Selection')
-    agent_group.add_argument(
+    common.add_argument(
         "--agent-class",
-        help="Name of the agent class to use (required only if multiple agents in file)"
+        help="Specify agent class (required if file has multiple agents)"
+    )
+    common.add_argument(
+        "--route",
+        help="Specify service by route (e.g., /healthcare, /finance)"
     )
     
-    agent_group.add_argument(
+    # Actions (choose one)
+    actions = parser.add_argument_group('actions (choose one)')
+    actions.add_argument(
         "--list-agents",
         action="store_true",
-        help="List all available agents in the file and exit"
+        help="List all agents in file"
     )
-    
-    agent_group.add_argument(
+    actions.add_argument(
         "--list-tools",
         action="store_true",
-        help="List all available tools in the agent and exit"
+        help="List all tools in agent"
     )
-    
-    # Output and Debugging Options
-    output_group = parser.add_argument_group('Output and Debugging Options')
-    output_group.add_argument(
-        "--verbose", "-v",
+    actions.add_argument(
+        "--dump-swml",
         action="store_true",
-        help="Enable verbose output"
+        help="Generate and output SWML document"
     )
-    
-    output_group.add_argument(
-        "--raw",
-        action="store_true",
-        help="Output raw SWML JSON only (no headers, useful for piping to jq/yq)"
+    actions.add_argument(
+        "--exec",
+        metavar="FUNCTION",
+        help="Execute function with CLI args (e.g., --exec search --query 'AI')"
     )
     
-    # SWML Generation and Testing
-    swml_group = parser.add_argument_group('SWML Generation and Testing')
-    swml_group.add_argument(
-        "--dump-swml",
+    # Function execution options
+    func_group = parser.add_argument_group('function execution options')
+    func_group.add_argument(
+        "--custom-data",
+        help="JSON string with custom post_data overrides",
+        default="{}"
+    )
+    func_group.add_argument(
+        "--minimal",
         action="store_true",
-        help="Dump the SWML document from the agent and exit"
+        help="Use minimal post_data for function execution"
     )
-    
-    swml_group.add_argument(
+    func_group.add_argument(
         "--fake-full-data",
-        action="store_true", 
-        help="Generate comprehensive fake post_data with all possible keys"
-    )
-    
-    swml_group.add_argument(
-        "--minimal",
         action="store_true",
-        help="Use minimal post_data (only essential keys)"
+        help="Use comprehensive fake post_data"
     )
     
-    # Call Configuration Options
-    call_group = parser.add_argument_group('Call Configuration Options')
-    call_group.add_argument(
+    # SWML generation options
+    swml_group = parser.add_argument_group('swml generation options')
+    swml_group.add_argument(
         "--call-type",
         choices=["sip", "webrtc"],
         default="webrtc",
-        help="Type of call for SWML generation (default: webrtc)"
+        help="Call type (default: webrtc)"
     )
-    
-    call_group.add_argument(
+    swml_group.add_argument(
         "--call-direction",
         choices=["inbound", "outbound"],
         default="inbound",
-        help="Direction of call for SWML generation (default: inbound)"
+        help="Call direction (default: inbound)"
     )
-    
-    call_group.add_argument(
+    swml_group.add_argument(
         "--call-state",
         default="created",
-        help="State of call for SWML generation (default: created)"
-    )
-    
-    call_group.add_argument(
-        "--call-id",
-        help="Override call_id in fake SWML post_data"
+        help="Call state (default: created)"
     )
-    
-    call_group.add_argument(
+    swml_group.add_argument(
         "--from-number",
-        help="Override 'from' address in fake SWML post_data"
+        help="Override from number"
     )
-    
-    call_group.add_argument(
+    swml_group.add_argument(
         "--to-extension",
-        help="Override 'to' address in fake SWML post_data"
-    )
-    
-    # SignalWire Platform Configuration
-    platform_group = parser.add_argument_group('SignalWire Platform Configuration')
-    platform_group.add_argument(
-        "--project-id",
-        help="Override project_id in fake SWML post_data"
-    )
-    
-    platform_group.add_argument(
-        "--space-id", 
-        help="Override space_id in fake SWML post_data"
+        help="Override to extension"
     )
     
-    # User Variables and Query Parameters
-    vars_group = parser.add_argument_group('User Variables and Query Parameters')
-    vars_group.add_argument(
+    # Data customization
+    data_group = parser.add_argument_group('data customization')
+    data_group.add_argument(
         "--user-vars",
-        help="JSON string for vars.userVariables in fake SWML post_data"
+        help="JSON string for userVariables"
     )
-    
-    vars_group.add_argument(
+    data_group.add_argument(
         "--query-params",
-        help="JSON string for query parameters (merged into userVariables)"
+        help="JSON string for query parameters"
     )
-    
-    # Data Override Options
-    override_group = parser.add_argument_group('Data Override Options')
-    override_group.add_argument(
+    data_group.add_argument(
         "--override",
         action="append",
         default=[],
-        help="Override specific values using dot notation (e.g., --override call.state=answered)"
-    )
-    
-    override_group.add_argument(
-        "--override-json",
-        action="append", 
-        default=[],
-        help="Override with JSON values using dot notation (e.g., --override-json vars.custom='{\"key\":\"value\"}')"
+        help="Override value (e.g., --override call.state=answered)"
     )
-    
-    # HTTP Request Simulation
-    http_group = parser.add_argument_group('HTTP Request Simulation')
-    http_group.add_argument(
+    data_group.add_argument(
         "--header",
         action="append",
         default=[],
-        help="Add HTTP headers for mock request (e.g., --header Authorization=Bearer token)"
-    )
-    
-    http_group.add_argument(
-        "--method",
-        default="POST",
-        help="HTTP method for mock request (default: POST)"
-    )
-    
-    http_group.add_argument(
-        "--body",
-        help="JSON string for mock request body"
+        help="Add HTTP header (e.g., --header Authorization=Bearer token)"
     )
     
-    # Serverless Environment Simulation
-    serverless_group = parser.add_argument_group('Serverless Environment Simulation')
+    # Serverless simulation (basic)
+    serverless_group = parser.add_argument_group('serverless simulation (use --help-platforms for platform options)')
     serverless_group.add_argument(
         "--simulate-serverless",
         choices=["lambda", "cgi", "cloud_function", "azure_function"],
-        help="Simulate serverless platform environment (lambda, cgi, cloud_function, azure_function)"
+        help="Simulate serverless platform"
     )
-    
     serverless_group.add_argument(
         "--env",
         action="append",
         default=[],
-        help="Set environment variable (e.g., --env API_KEY=secret123)"
+        help="Set environment variable (e.g., --env KEY=VALUE)"
     )
-    
     serverless_group.add_argument(
         "--env-file",
-        help="Load environment variables from file"
-    )
-    
-    serverless_group.add_argument(
-        "--serverless-mode",
-        help="Legacy option for serverless mode (use --simulate-serverless instead)"
-    )
-    
-    # AWS Lambda Configuration
-    aws_group = parser.add_argument_group('AWS Lambda Configuration')
-    aws_group.add_argument(
-        "--aws-function-name",
-        help="AWS Lambda function name (overrides default)"
-    )
-    
-    aws_group.add_argument(
-        "--aws-function-url",
-        help="AWS Lambda function URL (overrides default)"
-    )
-    
-    aws_group.add_argument(
-        "--aws-region",
-        help="AWS region (overrides default)"
-    )
-    
-    aws_group.add_argument(
-        "--aws-api-gateway-id",
-        help="AWS API Gateway ID for API Gateway URLs"
-    )
-    
-    aws_group.add_argument(
-        "--aws-stage",
-        help="AWS API Gateway stage (default: prod)"
-    )
-    
-    # CGI Configuration
-    cgi_group = parser.add_argument_group('CGI Configuration')
-    cgi_group.add_argument(
-        "--cgi-host",
-        help="CGI server hostname (required for CGI simulation)"
-    )
-    
-    cgi_group.add_argument(
-        "--cgi-script-name",
-        help="CGI script name/path (overrides default)"
-    )
-    
-    cgi_group.add_argument(
-        "--cgi-https",
+        help="Load environment from file"
+    )
+    
+    # Hidden/advanced options (not shown in main help)
+    parser.add_argument("--call-id", help=argparse.SUPPRESS)
+    parser.add_argument("--project-id", help=argparse.SUPPRESS)
+    parser.add_argument("--space-id", help=argparse.SUPPRESS)
+    parser.add_argument("--method", default="POST", help=argparse.SUPPRESS)
+    parser.add_argument("--body", help=argparse.SUPPRESS)
+    parser.add_argument("--override-json", action="append", default=[], help=argparse.SUPPRESS)
+    
+    # Platform-specific options (hidden from main help)
+    parser.add_argument("--aws-function-name", help=argparse.SUPPRESS)
+    parser.add_argument("--aws-function-url", help=argparse.SUPPRESS)
+    parser.add_argument("--aws-region", help=argparse.SUPPRESS)
+    parser.add_argument("--aws-api-gateway-id", help=argparse.SUPPRESS)
+    parser.add_argument("--aws-stage", help=argparse.SUPPRESS)
+    parser.add_argument("--cgi-host", help=argparse.SUPPRESS)
+    parser.add_argument("--cgi-script-name", help=argparse.SUPPRESS)
+    parser.add_argument("--cgi-https", action="store_true", help=argparse.SUPPRESS)
+    parser.add_argument("--cgi-path-info", help=argparse.SUPPRESS)
+    parser.add_argument("--gcp-project", help=argparse.SUPPRESS)
+    parser.add_argument("--gcp-function-url", help=argparse.SUPPRESS)
+    parser.add_argument("--gcp-region", help=argparse.SUPPRESS)
+    parser.add_argument("--gcp-service", help=argparse.SUPPRESS)
+    parser.add_argument("--azure-env", help=argparse.SUPPRESS)
+    parser.add_argument("--azure-function-url", help=argparse.SUPPRESS)
+    
+    # Help extension options
+    parser.add_argument(
+        "--help-platforms",
         action="store_true",
-        help="Use HTTPS for CGI URLs"
-    )
-    
-    cgi_group.add_argument(
-        "--cgi-path-info",
-        help="CGI PATH_INFO value"
-    )
-    
-    # Google Cloud Platform Configuration
-    gcp_group = parser.add_argument_group('Google Cloud Platform Configuration')
-    gcp_group.add_argument(
-        "--gcp-project",
-        help="Google Cloud project ID (overrides default)"
-    )
-    
-    gcp_group.add_argument(
-        "--gcp-function-url",
-        help="Google Cloud Function URL (overrides default)"
-    )
-    
-    gcp_group.add_argument(
-        "--gcp-region",
-        help="Google Cloud region (overrides default)"
-    )
-    
-    gcp_group.add_argument(
-        "--gcp-service",
-        help="Google Cloud service name (overrides default)"
-    )
-    
-    # Azure Functions Configuration
-    azure_group = parser.add_argument_group('Azure Functions Configuration')
-    azure_group.add_argument(
-        "--azure-env",
-        help="Azure Functions environment (overrides default)"
+        help="Show platform-specific serverless options"
     )
-    
-    azure_group.add_argument(
-        "--azure-function-url",
-        help="Azure Function URL (overrides default)"
+    parser.add_argument(
+        "--help-examples",
+        action="store_true",
+        help="Show comprehensive usage examples"
     )
     
     args = parser.parse_args()
@@ -2176,38 +443,26 @@ Examples:
     
     # Handle --exec vs positional tool_name
     if exec_function_name:
-        # Using --exec syntax, override any positional tool_name
         args.tool_name = exec_function_name
-        # function_args_list is already set from --exec parsing
+    else:
+        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 agents
-            args.list_agents = True
-        else:
-            # When using positional syntax, args_json is required
-            # When using --exec syntax, function_args_list is automatically populated
-            if not args.args_json and not function_args_list:
-                if exec_function_name:
-                    # --exec syntax doesn't require additional arguments (can be empty)
-                    pass
-                else:
-                    parser.error("Positional tool_name requires args_json parameter. Use --exec for CLI-style arguments.")
+            # If no tool_name and no special flags, default to listing tools
+            args.list_tools = True
     
     # ===== SERVERLESS SIMULATION SETUP =====
     serverless_simulator = None
     
-    # Handle legacy --serverless-mode option
-    if args.serverless_mode and not args.simulate_serverless:
-        args.simulate_serverless = args.serverless_mode
-        if not args.raw:
-            print("Warning: --serverless-mode is deprecated, use --simulate-serverless instead")
-    
     if args.simulate_serverless:
         # Validate CGI requirements
         if args.simulate_serverless == 'cgi' and not args.cgi_host:
-            parser.error("CGI simulation requires --cgi-host")
+            parser.error(ERROR_CGI_HOST_REQUIRED)
         
         # Collect environment variable overrides
         env_overrides = {}
@@ -2223,16 +478,13 @@ Examples:
                 print(f"Error: {e}")
                 return 1
         
-        # Parse --env arguments
-        for env_arg in args.env:
-            if '=' not in env_arg:
-                print(f"Error: Invalid environment variable format: {env_arg}")
-                print("Expected format: --env KEY=value")
-                return 1
-            key, value = env_arg.split('=', 1)
-            env_overrides[key] = value
+        # Apply individual env overrides
+        for env_var in args.env:
+            if '=' in env_var:
+                key, value = env_var.split('=', 1)
+                env_overrides[key] = value
         
-        # Add platform-specific overrides
+        # Apply platform-specific overrides
         if args.simulate_serverless == 'lambda':
             if args.aws_function_name:
                 env_overrides['AWS_LAMBDA_FUNCTION_NAME'] = args.aws_function_name
@@ -2240,21 +492,16 @@ Examples:
                 env_overrides['AWS_LAMBDA_FUNCTION_URL'] = args.aws_function_url
             if args.aws_region:
                 env_overrides['AWS_REGION'] = args.aws_region
-            if args.aws_api_gateway_id:
-                env_overrides['AWS_API_GATEWAY_ID'] = args.aws_api_gateway_id
-            if args.aws_stage:
-                env_overrides['AWS_API_GATEWAY_STAGE'] = args.aws_stage
-        
         elif args.simulate_serverless == 'cgi':
             if args.cgi_host:
                 env_overrides['HTTP_HOST'] = args.cgi_host
+                env_overrides['SERVER_NAME'] = args.cgi_host
             if args.cgi_script_name:
                 env_overrides['SCRIPT_NAME'] = args.cgi_script_name
             if args.cgi_https:
                 env_overrides['HTTPS'] = 'on'
             if args.cgi_path_info:
                 env_overrides['PATH_INFO'] = args.cgi_path_info
-        
         elif args.simulate_serverless == 'cloud_function':
             if args.gcp_project:
                 env_overrides['GOOGLE_CLOUD_PROJECT'] = args.gcp_project
@@ -2264,71 +511,49 @@ Examples:
                 env_overrides['GOOGLE_CLOUD_REGION'] = args.gcp_region
             if args.gcp_service:
                 env_overrides['K_SERVICE'] = args.gcp_service
-        
         elif args.simulate_serverless == 'azure_function':
             if args.azure_env:
                 env_overrides['AZURE_FUNCTIONS_ENVIRONMENT'] = args.azure_env
             if args.azure_function_url:
                 env_overrides['AZURE_FUNCTION_URL'] = args.azure_function_url
         
-        # Create and activate serverless simulator
+        # Create and activate simulator
         serverless_simulator = ServerlessSimulator(args.simulate_serverless, env_overrides)
-        try:
-            serverless_simulator.activate(args.verbose and not args.raw)
-        except Exception as e:
-            print(f"Error setting up serverless simulation: {e}")
-            return 1
+        serverless_simulator.activate(args.verbose and not args.raw)
     
+    # ===== MAIN EXECUTION =====
     try:
-        # Handle agent listing first (doesn't require loading a specific agent)
+        # Check if agent file exists
+        agent_path = Path(args.agent_path)
+        if not agent_path.exists():
+            print(f"Error: Agent file not found: {args.agent_path}")
+            return 1
+        
+        # Handle --list-agents
         if args.list_agents:
-            if args.verbose and not args.raw:
-                print(f"Discovering agents in: {args.agent_path}")
-            
             try:
                 agents = discover_agents_in_file(args.agent_path)
-                
                 if not agents:
-                    print("No agents found in the file.")
+                    print(ERROR_NO_AGENTS.format(file_path=args.agent_path))
                     return 1
                 
-                print(f"Available agents in {args.agent_path}:")
-                print()
-                
+                print(f"\nAgents found in {args.agent_path}:")
                 for agent_info in agents:
-                    print(f"  {agent_info['class_name']}")
-                    
+                    agent_type = "instance" if agent_info['type'] == 'instance' else "class"
+                    print(f"  {agent_info['class_name']} ({agent_type})")
                     if agent_info['type'] == 'instance':
-                        print(f"    Type: Ready instance")
                         print(f"    Name: {agent_info['agent_name']}")
                         print(f"    Route: {agent_info['route']}")
-                    else:
-                        print(f"    Type: Available class (needs instantiation)")
-                    
                     if agent_info['description']:
-                        # Clean up the description
+                        # Clean up description
                         desc = agent_info['description'].strip()
                         if desc:
-                            # Take first line or sentence
-                            first_line = desc.split('\n')[0].strip()
-                            print(f"    Description: {first_line}")
-                    
-                    print()
-                
-                if len(agents) > 1:
-                    print("To use a specific agent with this tool:")
-                    print(f"  swaig-test {args.agent_path} [tool_name] [args] --agent-class <AgentClassName>")
-                    print()
-                    print("Examples:")
-                    for agent_info in agents:
-                        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.")
-                
+                            # Take first line only
+                            desc_lines = desc.split('\n')
+                            first_line = desc_lines[0].strip()
+                            if first_line:
+                                print(f"    Description: {first_line}")
                 return 0
-                
             except Exception as e:
                 print(f"Error discovering agents: {e}")
                 if args.verbose:
@@ -2336,255 +561,227 @@ Examples:
                     traceback.print_exc()
                 return 1
         
-        # Load the agent for other operations
-        if args.verbose and not args.raw:
-            print(f"Loading agent from: {args.agent_path}")
+        # Load the agent
+        try:
+            # 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:
+                # When listing tools and multiple agents exist, show all agents with their tools
+                try:
+                    agents = discover_agents_in_file(args.agent_path)
+                    if agents:
+                        print(f"\nMultiple agents found in {args.agent_path}:")
+                        print("=" * 60)
+                        
+                        for agent_info in agents:
+                            if agent_info['type'] == 'class':
+                                print(f"\n{agent_info['class_name']}:")
+                                if agent_info['description']:
+                                    desc = agent_info['description'].strip().split('\n')[0]
+                                    if desc:
+                                        print(f"  Description: {desc}")
+                                
+                                # Try to load this specific agent and show its tools
+                                try:
+                                    specific_agent = load_agent_from_file(args.agent_path, agent_info['class_name'])
+                                    
+                                    # Apply dynamic configuration if the agent has it
+                                    # Create a basic mock request for dynamic config
+                                    try:
+                                        basic_mock_request = create_mock_request(
+                                            method="POST",
+                                            headers={},
+                                            query_params={},
+                                            body={}
+                                        )
+                                        apply_dynamic_config(specific_agent, basic_mock_request, verbose=False)
+                                    except Exception as dc_error:
+                                        if args.verbose:
+                                            print(f"    (Warning: Dynamic config failed: {dc_error})")
+                                    
+                                    functions = specific_agent._tool_registry.get_all_functions() if hasattr(specific_agent, '_tool_registry') else {}
+                                    
+                                    
+                                    if functions:
+                                        print(f"  Tools:")
+                                        for name, func in functions.items():
+                                            if isinstance(func, dict):
+                                                description = func.get('description', 'DataMap function')
+                                                print(f"    - {name}: {description}")
+                                            else:
+                                                print(f"    - {name}: {func.description}")
+                                    else:
+                                        print(f"  Tools: (none)")
+                                except Exception as load_error:
+                                    print(f"  Tools: (error loading agent: {load_error})")
+                                    if args.verbose:
+                                        import traceback
+                                        traceback.print_exc()
+                        
+                        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}")
+                    return 1
+            elif "Multiple agent classes found" in error_msg:
+                print(f"\n{ERROR_MULTIPLE_AGENTS}")
+                print(error_msg)
+            elif "not found" in error_msg and args.agent_class:
+                print(ERROR_AGENT_NOT_FOUND.format(
+                    class_name=args.agent_class,
+                    file_path=args.agent_path
+                ))
+            else:
+                print(f"Error: {error_msg}")
+            return 1
+        
+        # Create mock request for dynamic configuration
+        headers = {}
+        for header in args.header:
+            if '=' in header:
+                key, value = header.split('=', 1)
+                headers[key] = value
         
-        # Auto-select agent if only one exists and no --agent-class specified
-        agent_class_name = getattr(args, 'agent_class', None)
-        if not agent_class_name:
-            # Try to auto-discover if there's only one agent
+        query_params = {}
+        if args.query_params:
             try:
-                discovered_agents = discover_agents_in_file(args.agent_path)
-                if len(discovered_agents) == 1:
-                    agent_class_name = discovered_agents[0]['class_name']
-                    if args.verbose and not args.raw:
-                        print(f"Auto-selected agent: {agent_class_name}")
-                elif len(discovered_agents) > 1:
-                    if not args.raw:
-                        print(f"Multiple agents found: {[a['class_name'] for a in discovered_agents]}")
-                        print(f"Please specify --agent-class parameter")
-                    return 1
-            except Exception:
-                # If discovery fails, fall back to normal loading behavior
-                pass
+                query_params = json.loads(args.query_params)
+            except json.JSONDecodeError as e:
+                if not args.raw:
+                    print(f"Warning: Invalid JSON in --query-params: {e}")
         
-        agent = load_agent_from_file(args.agent_path, agent_class_name)
+        request_body = {}
+        if args.body:
+            try:
+                request_body = json.loads(args.body)
+            except json.JSONDecodeError as e:
+                if not args.raw:
+                    print(f"Warning: Invalid JSON in --body: {e}")
         
-        if args.verbose and not args.raw:
-            print(f"Loaded agent: {agent.get_name()}")
-            print(f"Agent route: {agent.route}")
-            
-            # Show loaded skills
-            skills = agent.list_skills()
-            if skills:
-                print(f"Loaded skills: {', '.join(skills)}")
-            else:
-                print("No skills loaded")
+        mock_request = create_mock_request(
+            method=args.method,
+            headers=headers,
+            query_params=query_params,
+            body=request_body
+        )
+        
+        # Apply dynamic configuration
+        apply_dynamic_config(agent, mock_request, verbose=args.verbose and not args.raw)
         
-        # List tools if requested
+        # Handle --list-tools
         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, verbose=args.verbose)
             return 0
         
-        # Dump SWML if requested
+        # Handle --dump-swml
         if args.dump_swml:
             return handle_dump_swml(agent, args)
         
-        # Parse function arguments
-        if function_args_list:
-            # Using --exec syntax, need to get the function to parse arguments with schema
-            if not hasattr(agent, '_swaig_functions') or args.tool_name not in agent._swaig_functions:
-                print(f"Error: Function '{args.tool_name}' not found in agent")
-                print(f"Available functions: {list(agent._swaig_functions.keys()) if hasattr(agent, '_swaig_functions') else 'None'}")
+        # Handle function execution
+        if args.tool_name:
+            # Get the function
+            functions = agent._tool_registry.get_all_functions() if hasattr(agent, '_tool_registry') else {}
+            
+            if args.tool_name not in functions:
+                print(ERROR_FUNCTION_NOT_FOUND.format(function_name=args.tool_name))
+                display_agent_tools(agent, verbose=False)
                 return 1
             
-            func = agent._swaig_functions[args.tool_name]
+            func = functions[args.tool_name]
             
+            # Parse function arguments
             try:
                 function_args = parse_function_arguments(function_args_list, func)
-                if args.verbose and not args.raw:
-                    print(f"Parsed arguments: {json.dumps(function_args, indent=2)}")
             except ValueError as e:
-                print(f"Error: {e}")
-                return 1
-        elif args.args_json:
-            # Using legacy JSON syntax
-            try:
-                function_args = json.loads(args.args_json)
-            except json.JSONDecodeError as e:
-                print(f"Error: Invalid JSON in args: {e}")
-                return 1
-        else:
-            # No arguments provided
-            function_args = {}
-        
-        try:
-            custom_data = json.loads(args.custom_data)
-        except json.JSONDecodeError as e:
-            print(f"Error: Invalid JSON in custom-data: {e}")
-            return 1
-        
-        # Check if the function exists (if not already checked)
-        if not function_args_list:
-            if not hasattr(agent, '_swaig_functions') or args.tool_name not in agent._swaig_functions:
-                print(f"Error: Function '{args.tool_name}' not found in agent")
-                print(f"Available functions: {list(agent._swaig_functions.keys()) if hasattr(agent, '_swaig_functions') else 'None'}")
+                print(f"Error parsing arguments: {e}")
                 return 1
             
-            func = agent._swaig_functions[args.tool_name]
-        else:
-            # Function already retrieved during argument parsing
-            func = agent._swaig_functions[args.tool_name]
-        
-        # Determine function type automatically - no --datamap flag needed
-        # DataMap functions are stored as dicts with 'data_map' key, webhook functions as SWAIGFunction objects
-        is_datamap = isinstance(func, dict) and 'data_map' in func
-        
-        if is_datamap:
-            # DataMap function execution
-            if args.verbose:
-                print(f"\nExecuting DataMap function: {args.tool_name}")
-                print(f"Arguments: {json.dumps(function_args, indent=2)}")
-                print("-" * 60)
+            # Check if this is a DataMap function
+            is_datamap = isinstance(func, dict) and 'data_map' in func
             
-            try:
-                result = execute_datamap_function(func, function_args, args.verbose)
+            # Check if this is an external webhook function
+            is_external_webhook = (hasattr(func, 'webhook_url') and 
+                                 func.webhook_url and 
+                                 hasattr(func, 'is_external') and 
+                                 func.is_external)
+            
+            if is_datamap:
+                if args.verbose:
+                    print(f"\nCalling DataMap function: {args.tool_name}")
+                    print(f"Arguments: {json.dumps(function_args, indent=2)}")
+                    print(f"Function type: DataMap (serverless)")
+                    print("-" * 60)
                 
+                # Execute DataMap function
+                result = execute_datamap_function(func, function_args, args.verbose)
                 print("RESULT:")
                 print(format_result(result))
-                
+            else:
+                # Regular SWAIG function
                 if args.verbose:
-                    print(f"\nRaw result type: {type(result).__name__}")
-                    print(f"Raw result: {repr(result)}")
+                    print(f"\nCalling function: {args.tool_name}")
+                    print(f"Arguments: {json.dumps(function_args, indent=2)}")
+                    if is_external_webhook:
+                        print(f"Function type: EXTERNAL webhook")
+                        print(f"External URL: {func.webhook_url}")
+                    else:
+                        print(f"Function type: LOCAL webhook")
                 
-            except Exception as e:
-                print(f"Error executing DataMap function: {e}")
-                if args.verbose:
-                    import traceback
-                    traceback.print_exc()
-                return 1
-        
-        else:
-            # Webhook function execution
-            if args.verbose:
-                print(f"\nCalling webhook function: {args.tool_name}")
-                print(f"Arguments: {json.dumps(function_args, indent=2)}")
-                print(f"Function description: {func.description}")
-            
-            # Check if this is an external webhook function
-            is_external_webhook = hasattr(func, 'webhook_url') and func.webhook_url and func.is_external
-            
-            if args.verbose and is_external_webhook:
-                print(f"Function type: EXTERNAL webhook")
-                print(f"External URL: {func.webhook_url}")
-            elif args.verbose:
-                print(f"Function type: LOCAL webhook")
-            
-            # Generate post_data based on options
-            if args.minimal:
-                post_data = generate_minimal_post_data(args.tool_name, function_args)
-                if custom_data:
-                    post_data.update(custom_data)
-            elif args.fake_full_data or custom_data:
-                post_data = generate_comprehensive_post_data(args.tool_name, function_args, custom_data)
-            else:
-                # Default behavior - minimal data
-                post_data = generate_minimal_post_data(args.tool_name, function_args)
-            
-            if args.verbose:
-                print(f"Post data: {json.dumps(post_data, indent=2)}")
-                print("-" * 60)
-            
-            # Call the function
-            try:
-                if is_external_webhook:
-                    # For external webhook functions, make HTTP request to external service
-                    result = execute_external_webhook_function(func, args.tool_name, function_args, post_data, args.verbose)
+                # Generate post_data based on options
+                if args.minimal:
+                    post_data = generate_minimal_post_data(args.tool_name, function_args)
+                    if args.custom_data:
+                        custom_data = json.loads(args.custom_data)
+                        post_data.update(custom_data)
+                elif args.fake_full_data or args.custom_data:
+                    custom_data = json.loads(args.custom_data) if args.custom_data else None
+                    post_data = generate_comprehensive_post_data(args.tool_name, function_args, custom_data)
                 else:
-                    # For local webhook functions, call the agent's handler
-                    result = agent.on_function_call(args.tool_name, function_args, post_data)
+                    # Default behavior - minimal data
+                    post_data = generate_minimal_post_data(args.tool_name, function_args)
                 
-                print("RESULT:")
-                print(format_result(result))
+                # Apply convenience mappings from CLI args (e.g., --call-id)
+                post_data = apply_convenience_mappings(post_data, args)
                 
-                if args.verbose:
-                    print(f"\nRaw result type: {type(result).__name__}")
-                    print(f"Raw result: {repr(result)}")
+                # Apply explicit overrides
+                post_data = apply_overrides(post_data, args.override, args.override_json)
                 
-            except Exception as e:
-                print(f"Error calling function: {e}")
                 if args.verbose:
-                    import traceback
-                    traceback.print_exc()
-                return 1
+                    print(f"Post data: {json.dumps(post_data, indent=2)}")
+                    print("-" * 60)
+                
+                # Call the function
+                try:
+                    if is_external_webhook:
+                        # For external webhook functions, make HTTP request to external service
+                        result = execute_external_webhook_function(func, args.tool_name, function_args, post_data, args.verbose)
+                    else:
+                        # For local webhook functions, call the agent's handler
+                        result = agent.on_function_call(args.tool_name, function_args, post_data)
+                    
+                    print("RESULT:")
+                    print(format_result(result))
+                    
+                    if args.verbose:
+                        print(f"\nRaw result type: {type(result).__name__}")
+                        print(f"Raw result: {repr(result)}")
+                    
+                except Exception as e:
+                    print(f"Error calling function: {e}")
+                    if args.verbose:
+                        import traceback
+                        traceback.print_exc()
+                    return 1
             
     except Exception as e:
         print(f"Error: {e}")
@@ -2602,8 +799,11 @@ Examples:
 
 def console_entry_point():
     """Console script entry point for pip installation"""
+    # Check for --dump-swml or --raw BEFORE imports happen
+    if "--raw" in sys.argv or "--dump-swml" in sys.argv:
+        os.environ['SIGNALWIRE_LOG_MODE'] = 'off'
     sys.exit(main())
 
 
 if __name__ == "__main__":
-    sys.exit(main()) 
+    sys.exit(main())