signalwire-agents 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

signalwire_agents/cli/output/output_formatter.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""
+Display agent/tools and format results
+"""
+
+import json
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from signalwire_agents.core.agent_base import AgentBase
+    from signalwire_agents.core.function_result import SwaigFunctionResult
+
+
+def display_agent_tools(agent: 'AgentBase', verbose: bool = False) -> None:
+    """
+    Display the available SWAIG functions for an agent
+    
+    Args:
+        agent: The agent instance
+        verbose: Whether to show verbose details
+    """
+    print("\nAvailable SWAIG functions:")
+    # Try to access functions from the tool registry
+    functions = {}
+    if hasattr(agent, '_tool_registry') and hasattr(agent._tool_registry, '_swaig_functions'):
+        functions = agent._tool_registry._swaig_functions
+    elif hasattr(agent, '_swaig_functions'):
+        functions = agent._swaig_functions
+    
+    if functions:
+        for name, func in functions.items():
+            if isinstance(func, dict):
+                # DataMap function
+                description = func.get('description', 'DataMap function (serverless)')
+                print(f"  {name} - {description}")
+                
+                # Show parameters for DataMap functions
+                if 'parameters' in func and func['parameters']:
+                    params = func['parameters']
+                    # Handle both formats: direct properties dict or full schema
+                    if 'properties' in params:
+                        properties = params['properties']
+                        required_fields = params.get('required', [])
+                    else:
+                        properties = params
+                        required_fields = []
+                    
+                    if properties:
+                        print(f"    Parameters:")
+                        for param_name, param_def in properties.items():
+                            param_type = param_def.get('type', 'unknown')
+                            param_desc = param_def.get('description', 'No description')
+                            is_required = param_name in required_fields
+                            required_marker = " (required)" if is_required else ""
+                            print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
+                    else:
+                        print(f"    Parameters: None")
+                else:
+                    print(f"    Parameters: None")
+                    
+                if verbose:
+                    print(f"    Config: {json.dumps(func, indent=6)}")
+            else:
+                # Regular SWAIG function
+                func_type = ""
+                if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
+                    func_type = " (EXTERNAL webhook)"
+                elif hasattr(func, 'webhook_url') and func.webhook_url:
+                    func_type = " (webhook)"
+                else:
+                    func_type = " (LOCAL webhook)"
+                
+                print(f"  {name} - {func.description}{func_type}")
+                
+                # Show external URL if applicable
+                if hasattr(func, 'webhook_url') and func.webhook_url and func.is_external:
+                    print(f"    External URL: {func.webhook_url}")
+                
+                # Show parameters
+                if hasattr(func, 'parameters') and func.parameters:
+                    params = func.parameters
+                    # Handle both formats: direct properties dict or full schema
+                    if 'properties' in params:
+                        properties = params['properties']
+                        required_fields = params.get('required', [])
+                    else:
+                        properties = params
+                        required_fields = []
+                    
+                    if properties:
+                        print(f"    Parameters:")
+                        for param_name, param_def in properties.items():
+                            param_type = param_def.get('type', 'unknown')
+                            param_desc = param_def.get('description', 'No description')
+                            is_required = param_name in required_fields
+                            required_marker = " (required)" if is_required else ""
+                            print(f"      {param_name} ({param_type}){required_marker}: {param_desc}")
+                    else:
+                        print(f"    Parameters: None")
+                else:
+                    print(f"    Parameters: None")
+                    
+                if verbose:
+                    print(f"    Function object: {func}")
+    else:
+        print("  No SWAIG functions registered")
+
+
+def 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
+    """
+    # Import here to avoid circular imports
+    from signalwire_agents.core.function_result import SwaigFunctionResult
+    
+    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}"

signalwire_agents/cli/output/swml_dump.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Handle SWML document dumping
+"""
+
+import sys
+import json
+import warnings
+import argparse
+from typing import TYPE_CHECKING
+from ..simulation.data_generation import generate_fake_swml_post_data
+from ..simulation.data_overrides import apply_convenience_mappings, apply_overrides
+from ..simulation.mock_env import create_mock_request
+from ..core.dynamic_config import apply_dynamic_config
+
+if TYPE_CHECKING:
+    from signalwire_agents.core.agent_base import AgentBase
+
+
+# Store the original print function for raw mode
+original_print = print
+
+
+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 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:
+        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
+            functions = agent._tool_registry.get_all_functions() if hasattr(agent, '_tool_registry') else {}
+            if functions:
+                print(f"Functions: {', '.join(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)
+        
+        # Apply dynamic configuration with the mock request
+        apply_dynamic_config(agent, mock_request, verbose=args.verbose and not args.raw)
+        
+        # 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:
+            # Output formatted JSON (like raw but pretty-printed)
+            try:
+                swml_parsed = json.loads(swml_doc)
+                print(json.dumps(swml_parsed, indent=2))
+            except json.JSONDecodeError:
+                # If not valid JSON, show raw
+                print(swml_doc)
+        
+        return 0
+        
+    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

signalwire_agents/cli/simulation/__init__.py

@@ -0,0 +1 @@
+"""Simulation and mock environment modules"""

signalwire_agents/cli/simulation/data_generation.py

@@ -0,0 +1,365 @@
+#!/usr/bin/env python3
+"""
+Generate fake SWML post_data and related helpers
+"""
+
+import uuid
+import json
+from datetime import datetime
+from typing import Dict, Any, Optional
+from ..types import CallData, VarsData, PostData
+
+
+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
+
+
+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())
+    project_id = str(uuid.uuid4())
+    space_id = str(uuid.uuid4())
+    space_name = "test-space"
+    environment = "production"
+    
+    current_time = datetime.now().isoformat()
+    
+    # Base structure with all keys
+    post_data = {
+        "call_id": call_id,
+        "call": {
+            "call_id": call_id,
+            "node_id": f"test-node-{uuid.uuid4().hex[:8]}",
+            "segment_id": str(uuid.uuid4()),
+            "call_session_id": str(uuid.uuid4()),
+            "to": "+15551234567",
+            "from": "+15559876543",
+            "direction": "inbound",
+            "state": "answered",
+            "tag": call_id,
+            "project_id": project_id,
+            "space_id": space_id,
+            "headers": {"User-Agent": "SignalWire/1.0"},
+            "type": "phone",
+            "timeout": 30,
+            "answer_on_bridge": False,
+            "created_at": current_time,
+            "updated_at": current_time
+        },
+        "vars": {
+            "environment": environment,
+            "space_id": space_id,
+            "userVariables": {},
+            "call_data": {
+                "id": call_id,
+                "state": "answered",
+                "type": "phone",
+                "from": "+15559876543",
+                "to": "+15551234567",
+                "project_id": project_id,
+                "created_at": current_time
+            }
+        },
+        "params": args,
+        "space_id": space_id,
+        "project_id": project_id,
+        "meta_data": {
+            "application": {
+                "name": "SignalWire AI Agent",
+                "version": "1.0.0"
+            },
+            "swml": {
+                "version": "1.0.0",
+                "session_id": session_id
+            },
+            "ai": {
+                "call_id": call_id,
+                "session_id": session_id,
+                "conversation_id": session_id
+            },
+            "request": {
+                "method": "POST",
+                "source_ip": "192.168.1.1",
+                "user_agent": "SignalWire-AI-Agent/1.0"
+            },
+            "timing": {
+                "request_start": current_time,
+                "function_start": current_time
+            },
+            "user": {
+                "id": f"user-{uuid.uuid4().hex[:8]}",
+                "session_start": current_time,
+                "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
+        },
+        
+        # SignalWire environment data
+        "swml_env": {
+            "space_id": space_id,
+            "project_id": project_id,
+            "environment": environment,
+            "space_name": space_name,
+            "api_version": "1.0.0"
+        }
+    }
+    
+    # Apply custom data overrides if provided
+    if custom_data:
+        # Deep merge custom_data into post_data
+        for key, value in custom_data.items():
+            if key in post_data and isinstance(post_data[key], dict) and isinstance(value, dict):
+                # Merge dictionaries
+                post_data[key].update(value)
+            else:
+                # Replace value
+                post_data[key] = value
+    
+    return post_data
+
+
+def generate_minimal_post_data(function_name: str, args: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Generate minimal post_data with only essential keys
+    
+    Args:
+        function_name: Name of the SWAIG function being called
+        args: Function arguments
+        
+    Returns:
+        Minimal post_data dict
+    """
+    call_id = str(uuid.uuid4())
+    
+    return {
+        "call_id": call_id,
+        "params": args
+    }